پیکربندی استاندارد 8 پایه:
   ┌───┐
 1 │ ● │ 8   پایه 1: آند LED کانال 1
 2 │   │ 7   پایه 2: کاتد LED کانال 1
 3 │   │ 6   پایه 3: آند LED کانال 2
 4 │   │ 5   پایه 4: کاتد LED کانال 2
   └───┘    پایه 5: امیتر کانال 2
            پایه 6: کلکتور کانال 2
            پایه 7: امیتر کانال 1
            پایه 8: کلکتور کانال 1

کانال 1: [LED1] → [نور] → [فوتوترانزیستور1] → خروجی 1
کانال 2: [LED2] → [نور] → [فوتوترانزیستور2] → خروجی 2
          ↓         ↓            ↓             ↓
     ورودی 1   محیط عایق   گیرنده 1       خروجی 1
     ورودی 2             گیرنده 2       خروجی 2

// تعریف پایه‌های اپتوکوپلر دو حالته PC827
#define CH1_INPUT_PIN   2    // کنترل LED کانال 1
#define CH1_OUTPUT_PIN  3    // خواندن خروجی کانال 1
#define CH2_INPUT_PIN   4    // کنترل LED کانال 2
#define CH2_OUTPUT_PIN  5    // خواندن خروجی کانال 2

// پین‌های اضافی برای حالت‌های خاص
#define CH1_ENABLE_PIN  6    // فعال‌سازی کانال 1 (اختیاری)
#define CH2_ENABLE_PIN  7    // فعال‌سازی کانال 2 (اختیاری)

void setupDualOptocoupler() {
    Serial.begin(115200);
    
    // تنظیم پین‌های کنترل
    pinMode(CH1_INPUT_PIN, OUTPUT);
    pinMode(CH1_OUTPUT_PIN, INPUT);
    pinMode(CH2_INPUT_PIN, OUTPUT);
    pinMode(CH2_OUTPUT_PIN, INPUT);
    
    // تنظیم پین‌های فعال‌سازی
    if (CH1_ENABLE_PIN != -1) {
        pinMode(CH1_ENABLE_PIN, OUTPUT);
        digitalWrite(CH1_ENABLE_PIN, HIGH); // فعال به طور پیش‌فرض
    }
    if (CH2_ENABLE_PIN != -1) {
        pinMode(CH2_ENABLE_PIN, OUTPUT);
        digitalWrite(CH2_ENABLE_PIN, HIGH);
    }
    
    // حالت اولیه
    digitalWrite(CH1_INPUT_PIN, LOW);
    digitalWrite(CH2_INPUT_PIN, LOW);
    
    Serial.println("ماژول اپتوکوپلر دو حالته راه‌اندازی شد");
    Serial.println("=====================================");
    
    // تست اولیه
    testBothChannels();
}

void testBothChannels() {
    Serial.println("=== تست اولیه دو کانال ===");
    
    // تست کانال 1
    Serial.println("تست کانال 1:");
    testSingleChannel(CH1_INPUT_PIN, CH1_OUTPUT_PIN, "کانال 1");
    
    // تست کانال 2
    Serial.println("تست کانال 2:");
    testSingleChannel(CH2_INPUT_PIN, CH2_OUTPUT_PIN, "کانال 2");
    
    // تست همزمان
    Serial.println("تست همزمان دو کانال:");
    testSimultaneous();
}

void testSingleChannel(int inputPin, int outputPin, String channelName) {
    digitalWrite(inputPin, HIGH);
    delayMicroseconds(50);
    bool outputState = digitalRead(outputPin);
    Serial.print(channelName);
    Serial.print(" - ورودی HIGH، خروجی: ");
    Serial.println(outputState ? "HIGH" : "LOW");
    
    digitalWrite(inputPin, LOW);
    delayMicroseconds(50);
    outputState = digitalRead(outputPin);
    Serial.print(channelName);
    Serial.print(" - ورودی LOW، خروجی: ");
    Serial.println(outputState ? "HIGH" : "LOW");
}

class DualChannelOptocoupler {
private:
    struct Channel {
        int inputPin;
        int outputPin;
        int enablePin;
        bool isEnabled;
        bool isInverting;
        unsigned long responseTime;
        float ctr;
        String name;
    };
    
    Channel channels[2];
    bool channelsSynchronized;
    
public:
    DualChannelOptocoupler(
        int ch1In, int ch1Out, 
        int ch2In, int ch2Out,
        int ch1En = -1, int ch2En = -1,
        bool ch1Inv = false, bool ch2Inv = false
    ) {
        // تنظیم کانال 1
        channels[0].inputPin = ch1In;
        channels[0].outputPin = ch1Out;
        channels[0].enablePin = ch1En;
        channels[0].isInverting = ch1Inv;
        channels[0].isEnabled = true;
        channels[0].responseTime = 10;
        channels[0].ctr = 100.0;
        channels[0].name = "کانال 1";
        
        // تنظیم کانال 2
        channels[1].inputPin = ch2In;
        channels[1].outputPin = ch2Out;
        channels[1].enablePin = ch2En;
        channels[1].isInverting = ch2Inv;
        channels[1].isEnabled = true;
        channels[1].responseTime = 10;
        channels[1].ctr = 100.0;
        channels[1].name = "کانال 2";
        
        channelsSynchronized = false;
        
        // تنظیم پین‌ها
        initializePins();
    }
    
    void initializePins() {
        for (int i = 0; i < 2; i++) {
            pinMode(channels[i].inputPin, OUTPUT);
            pinMode(channels[i].outputPin, INPUT);
            
            if (channels[i].enablePin != -1) {
                pinMode(channels[i].enablePin, OUTPUT);
                digitalWrite(channels[i].enablePin, HIGH);
            }
            
            // حالت اولیه
            digitalWrite(channels[i].inputPin, LOW);
        }
        
        Serial.println("اپتوکوپلر دو کاناله آماده است");
    }
    
    void enableChannel(int channel, bool enable) {
        if (channel >= 0 && channel < 2) {
            channels[channel].isEnabled = enable;
            
            if (channels[channel].enablePin != -1) {
                digitalWrite(channels[channel].enablePin, enable ? HIGH : LOW);
            }
            
            Serial.print(channels[channel].name);
            Serial.println(enable ? " فعال شد" : " غیرفعال شد");
        }
    }
    
    void setChannel(int channel, bool state) {
        if (channel >= 0 && channel < 2 && channels[channel].isEnabled) {
            digitalWrite(channels[channel].inputPin, state ? HIGH : LOW);
            
            if (channels[channel].responseTime > 0) {
                delayMicroseconds(channels[channel].responseTime);
            }
        }
    }
    
    bool getChannelOutput(int channel) {
        if (channel >= 0 && channel < 2) {
            bool rawState = digitalRead(channels[channel].outputPin);
            return channels[channel].isInverting ? !rawState : rawState;
        }
        return false;
    }
    
    void setBothChannels(bool ch1State, bool ch2State) {
        if (channelsSynchronized) {
            // روشن کردن همزمان
            unsigned long startTime = micros();
            
            digitalWrite(channels[0].inputPin, ch1State ? HIGH : LOW);
            digitalWrite(channels[1].inputPin, ch2State ? HIGH : LOW);
            
            // انتظار برای آهسته‌ترین کانال
            unsigned long maxResponse = max(channels[0].responseTime, channels[1].responseTime);
            while (micros() - startTime < maxResponse) {
                // انتظار
            }
        } else {
            setChannel(0, ch1State);
            setChannel(1, ch2State);
        }
    }
    
    void toggleChannel(int channel) {
        bool currentState = digitalRead(channels[channel].inputPin);
        setChannel(channel, !currentState);
    }
    
    void toggleBoth() {
        bool ch1State = digitalRead(channels[0].inputPin);
        bool ch2State = digitalRead(channels[1].inputPin);
        
        setBothChannels(!ch1State, !ch2State);
    }
    
    void pulseChannel(int channel, unsigned long durationUs) {
        setChannel(channel, HIGH);
        delayMicroseconds(durationUs);
        setChannel(channel, LOW);
    }
    
    void pulseBoth(unsigned long durationUs, bool simultaneous = true) {
        if (simultaneous) {
            unsigned long startTime = micros();
            setBothChannels(HIGH, HIGH);
            while (micros() - startTime < durationUs) {
                // انتظار
            }
            setBothChannels(LOW, LOW);
        } else {
            pulseChannel(0, durationUs);
            pulseChannel(1, durationUs);
        }
    }
    
    void setResponseTime(int channel, unsigned long timeUs) {
        if (channel >= 0 && channel < 2) {
            channels[channel].responseTime = timeUs;
            Serial.print(channels[channel].name);
            Serial.print(" - زمان پاسخ تنظیم شد: ");
            Serial.print(timeUs);
            Serial.println(" µs");
        }
    }
    
    void synchronizeChannels(bool sync) {
        channelsSynchronized = sync;
        Serial.print("همگام‌سازی کانال‌ها: ");
        Serial.println(sync ? "فعال" : "غیرفعال");
    }
    
    void measureChannelMatching() {
        Serial.println("=== اندازه‌گیری تطابق کانال‌ها ===");
        
        unsigned long responseTimes[2][2]; // [کانال][Ton/Toff]
        
        // اندازه‌گیری زمان روشن شدن
        for (int i = 0; i < 2; i++) {
            unsigned long startTime = micros();
            setChannel(i, HIGH);
            responseTimes[i][0] = micros() - startTime;
        }
        
        // اندازه‌گیری زمان خاموش شدن
        for (int i = 0; i < 2; i++) {
            unsigned long startTime = micros();
            setChannel(i, LOW);
            responseTimes[i][1] = micros() - startTime;
        }
        
        // نمایش نتایج
        Serial.println("کانال | Ton (µs) | Toff (µs)");
        Serial.println("------|----------|----------");
        for (int i = 0; i < 2; i++) {
            Serial.print(channels[i].name);
            Serial.print(" | ");
            Serial.print(responseTimes[i][0]);
            Serial.print("     | ");
            Serial.println(responseTimes[i][1]);
        }
        
        // محاسبه اختلاف
        unsigned long tonDiff = abs(responseTimes[0][0] - responseTimes[1][0]);
        unsigned long toffDiff = abs(responseTimes[0][1] - responseTimes[1][1]);
        
        Serial.print("اختلاف Ton: ");
        Serial.print(tonDiff);
        Serial.print("µs (");
        Serial.print((tonDiff * 100.0) / max(responseTimes[0][0], responseTimes[1][0]), 1);
        Serial.println("%)");
        
        Serial.print("اختلاف Toff: ");
        Serial.print(toffDiff);
        Serial.print("µs (");
        Serial.print((toffDiff * 100.0) / max(responseTimes[0][1], responseTimes[1][1]), 1);
        Serial.println("%)");
    }
    
    void runComprehensiveTest() {
        Serial.println("=== تست جامع دو کاناله ===");
        
        // تست تکی
        for (int i = 0; i < 2; i++) {
            Serial.println("\n" + channels[i].name + ":");
            channelComprehensiveTest(i);
        }
        
        // تست همزمان
        Serial.println("\nتست همزمان:");
        simultaneousChannelTest();
        
        // تست تطابق
        Serial.println("\nتست تطابق:");
        measureChannelMatching();
        
        Serial.println("\n✅ تست کامل شد");
    }
    
    void channelComprehensiveTest(int channel) {
        // تست پالس‌های مختلف
        unsigned long pulseWidths[] = {10, 50, 100, 500, 1000}; // µs
        
        for (int i = 0; i < 5; i++) {
            Serial.print("پالس ");
            Serial.print(pulseWidths[i]);
            Serial.print("µs: ");
            
            unsigned long errors = 0;
            for (int j = 0; j < 10; j++) {
                unsigned long startTime = micros();
                setChannel(channel, HIGH);
                bool onState = getChannelOutput(channel);
                
                delayMicroseconds(pulseWidths[i]);
                
                setChannel(channel, LOW);
                bool offState = getChannelOutput(channel);
                unsigned long endTime = micros();
                
                if (!onState || offState) {
                    errors++;
                }
                
                delayMicroseconds(100); // فاصله بین پالس‌ها
            }
            
            if (errors == 0) {
                Serial.println("✅ PASS");
            } else {
                Serial.print("❌ FAIL (");
                Serial.print(errors);
                Serial.println(" خطا)");
            }
        }
    }
};

class IsolatedLogicGate {
private:
    DualChannelOptocoupler opto;
    bool lastOutput;
    
public:
    IsolatedLogicGate(int ch1In, int ch1Out, int ch2In, int ch2Out) 
        : opto(ch1In, ch1Out, ch2In, ch2Out) {
        lastOutput = false;
    }
    
    // AND Gate ایزوله
    bool isolatedAND(bool inputA, bool inputB) {
        opto.setChannel(0, inputA);
        opto.setChannel(1, inputB);
        
        bool outputA = opto.getChannelOutput(0);
        bool outputB = opto.getChannelOutput(1);
        
        return outputA && outputB;
    }
    
    // OR Gate ایزوله
    bool isolatedOR(bool inputA, bool inputB) {
        opto.setChannel(0, inputA);
        opto.setChannel(1, inputB);
        
        bool outputA = opto.getChannelOutput(0);
        bool outputB = opto.getChannelOutput(1);
        
        return outputA || outputB;
    }
    
    // XOR Gate ایزوله
    bool isolatedXOR(bool inputA, bool inputB) {
        opto.setChannel(0, inputA);
        opto.setChannel(1, inputB);
        
        bool outputA = opto.getChannelOutput(0);
        bool outputB = opto.getChannelOutput(1);
        
        return outputA != outputB;
    }
    
    // NAND Gate ایزوله
    bool isolatedNAND(bool inputA, bool inputB) {
        return !isolatedAND(inputA, inputB);
    }
    
    // Flip-Flop ایزوله
    bool isolatedSRFlipFlop(bool set, bool reset) {
        static bool state = false;
        
        if (set && !reset) {
            state = true;
        } else if (!set && reset) {
            state = false;
        }
        // اگر هر دو 1 باشند، حالت تعریف نشده
        
        opto.setChannel(0, state);
        opto.setChannel(1, !state); // خروجی معکوس
        
        return state;
    }
    
    // Schmitt Trigger ایزوله
    bool isolatedSchmittTrigger(float voltage, float lowThreshold, float highThreshold) {
        static bool state = false;
        
        if (voltage > highThreshold) {
            state = true;
        } else if (voltage < lowThreshold) {
            state = false;
        }
        
        opto.setChannel(0, state);
        return state;
    }
};

class IsolatedHBridgeDriver {
private:
    DualChannelOptocoupler highSideOpto;
    DualChannelOptocoupler lowSideOpto;
    float deadTime; // میکروثانیه
    enum BridgeState { STOP, FORWARD, REVERSE, BRAKE } currentState;
    
public:
    IsolatedHBridgeDriver(
        // High Side
        int hsCh1In, int hsCh1Out,
        int hsCh2In, int hsCh2Out,
        // Low Side
        int lsCh1In, int lsCh1Out,
        int lsCh2In, int lsCh2Out,
        float deadTimeUs = 2.0
    ) : highSideOpto(hsCh1In, hsCh1Out, hsCh2In, hsCh2Out),
        lowSideOpto(lsCh1In, lsCh1Out, lsCh2In, lsCh2Out),
        deadTime(deadTimeUs) {
        
        currentState = STOP;
        highSideOpto.synchronizeChannels(true);
        lowSideOpto.synchronizeChannels(true);
        
        // غیرفعال کردن همه کانال‌ها در ابتدا
        stop();
    }
    
    void forward() {
        if (currentState != FORWARD) {
            // خاموش کردن قبلی
            stop();
            delayMicroseconds(deadTime * 2);
            
            // روشن کردن Forward
            // High Side چپ، Low Side راست
            highSideOpto.setChannel(0, HIGH); // HS Left
            lowSideOpto.setChannel(1, HIGH);  // LS Right
            
            currentState = FORWARD;
            Serial.println("🔄 حرکت رو به جلو");
        }
    }
    
    void reverse() {
        if (currentState != REVERSE) {
            stop();
            delayMicroseconds(deadTime * 2);
            
            // روشن کردن Reverse
            // High Side راست، Low Side چپ
            highSideOpto.setChannel(1, HIGH); // HS Right
            lowSideOpto.setChannel(0, HIGH);  // LS Left
            
            currentState = REVERSE;
            Serial.println("🔁 حرکت معکوس");
        }
    }
    
    void stop() {
        // خاموش کردن همه
        highSideOpto.setBothChannels(LOW, LOW);
        lowSideOpto.setBothChannels(LOW, LOW);
        
        currentState = STOP;
        Serial.println("⏹️ توقف");
    }
    
    void brake() {
        // ترمز با اتصال کوتاه موتور
        highSideOpto.setBothChannels(LOW, LOW);
        lowSideOpto.setBothChannels(HIGH, HIGH);
        
        delay(100); // زمان ترمز
        stop();
        
        currentState = BRAKE;
        Serial.println("🛑 ترمز فعال");
    }
    
    void pwmControl(float dutyCycle, bool direction) {
        // کنترل PWM با جلوگیری از شوت-ترو
        unsigned long period = 1000; // 1ms دوره
        unsigned long onTime = period * dutyCycle;
        
        if (direction) {
            // Forward PWM
            highSideOpto.setChannel(0, HIGH);
            lowSideOpto.setChannel(1, HIGH);
            delayMicroseconds(onTime);
            
            highSideOpto.setChannel(0, LOW);
            delayMicroseconds(deadTime);
            
            lowSideOpto.setChannel(1, LOW);
        } else {
            // Reverse PWM
            highSideOpto.setChannel(1, HIGH);
            lowSideOpto.setChannel(0, HIGH);
            delayMicroseconds(onTime);
            
            highSideOpto.setChannel(1, LOW);
            delayMicroseconds(deadTime);
            
            lowSideOpto.setChannel(0, LOW);
        }
    }
    
    BridgeState getState() {
        return currentState;
    }
    
    void diagnosticCheck() {
        Serial.println("=== تست تشخیصی درایور پل H ===");
        
        // تست High Side
        Serial.println("تست High Side:");
        testHalfBridge(highSideOpto);
        
        // تست Low Side
        Serial.println("تست Low Side:");
        testHalfBridge(lowSideOpto);
        
        // تست امنیت
        checkSafety();
    }
};

class IsolatedSerialDuplex {
private:
    DualChannelOptocoupler txOpto; // ارسال
    DualChannelOptocoupler rxOpto; // دریافت
    int baudRate;
    unsigned long bitTime;
    
public:
    IsolatedSerialDuplex(
        // Transmitter
        int txCh1In, int txCh1Out,
        int txCh2In, int txCh2Out,
        // Receiver
        int rxCh1In, int rxCh1Out,
        int rxCh2In, int rxCh2Out,
        int baud = 9600
    ) : txOpto(txCh1In, txCh1Out, txCh2In, txCh2Out),
        rxOpto(rxCh1In, rxCh1Out, rxCh2In, rxCh2Out) {
        
        baudRate = baud;
        bitTime = 1000000 / baudRate; // میکروثانیه
        
        // تنظیم کانال‌ها برای ارتباط دوطرفه
        txOpto.synchronizeChannels(true);
        rxOpto.synchronizeChannels(false);
    }
    
    void sendChar(char c) {
        // Start bit (LOW)
        txOpto.setBothChannels(LOW, LOW);
        delayMicroseconds(bitTime);
        
        // 8 Data bits (LSB first)
        for (int i = 0; i < 8; i++) {
            bool bit = (c >> i) & 0x01;
            txOpto.setBothChannels(bit ? HIGH : LOW, bit ? HIGH : LOW);
            delayMicroseconds(bitTime);
        }
        
        // Stop bit (HIGH)
        txOpto.setBothChannels(HIGH, HIGH);
        delayMicroseconds(bitTime * 2); // دو بیت توقف برای اطمینان
    }
    
    void sendString(const String& str) {
        for (int i = 0; i < str.length(); i++) {
            sendChar(str.charAt(i));
        }
    }
    
    char receiveChar() {
        char received = 0;
        
        // منتظر Start bit
        waitForStartBit();
        
        // خواندن 8 بیت داده
        for (int i = 0; i < 8; i++) {
            delayMicroseconds(bitTime * 1.5); // نمونه‌برداری در وسط بیت
            
            bool bit1 = rxOpto.getChannelOutput(0);
            bool bit2 = rxOpto.getChannelOutput(1);
            
            // استفاده از کانالی که سیگنال واضح‌تری دارد
            bool bit = (bit1 && !bit2) ? true : (!bit1 && bit2) ? false : bit1;
            
            if (bit) {
                received |= (1 << i);
            }
        }
        
        // منتظر Stop bit
        delayMicroseconds(bitTime);
        
        return received;
    }
    
    String receiveString(int maxLength = 64) {
        String str = "";
        int count = 0;
        
        while (count < maxLength) {
            char c = receiveChar();
            if (c == '\0' || c == '\n') {
                break;
            }
            str += c;
            count++;
        }
        
        return str;
    }
    
    void halfDuplexCommunication(String message) {
        // ارتباط نیمه دوطرفه
        Serial.print("ارسال: ");
        Serial.println(message);
        sendString(message);
        
        // تغییر حالت به دریافت
        delay(100);
        
        Serial.print("دریافت: ");
        String response = receiveString();
        Serial.println(response);
    }
    
private:
    void waitForStartBit() {
        // منتظر LOW شدن (Start bit)
        while (true) {
            bool ch1 = rxOpto.getChannelOutput(0);
            bool ch2 = rxOpto.getChannelOutput(1);
            
            if (!ch1 && !ch2) {
                // Start bit تشخیص داده شد
                delayMicroseconds(bitTime * 1.5); // به وسط Start bit برو
                break;
            }
            delayMicroseconds(10);
        }
    }
};

// 1. حالت موازی برای جریان بالاتر
void parallelConfiguration() {
    Serial.println("پیکربندی موازی برای جریان بالاتر:");
    Serial.println("کانال‌ها به صورت موازی برای دوبرابر کردن جریان خروجی");
    Serial.println("LEDها سری با مقاومت‌های جداگانه");
    Serial.println("خروجی‌ها موازی با مقاومت بار مشترک");
}

// 2. حالت سری برای ولتاژ بالاتر
void seriesConfiguration() {
    Serial.println("پیکربندی سری برای ولتاژ بالاتر:");
    Serial.println("خروجی‌ها به صورت سری برای جمع ولتاژها");
    Serial.println("محدودیت: جریان یکسان در هر دو کانال");
}

// 3. حالت تفاضلی برای نویزگیری بهتر
void differentialConfiguration() {
    Serial.println("پیکربندی تفاضلی:");
    Serial.println("یک کانال برای سیگنال، دیگری برای زمین مجازی");
    Serial.println("نویز مد-مشترک حذف می‌شود");
}

// 4. حالت Redundant برای اطمینان بالا
void redundantConfiguration() {
    Serial.println("پیکربندی افزونگی:");
    Serial.println("هر دو کانال سیگنال یکسان را منتقل می‌کنند");
    Serial.println("اگر یک کانال خراب شود، کانال دیگر کار می‌کند");
    Serial.println("برای کاربردهای بحرانی");
}

class IsolatedStepperDriver {
private:
    DualChannelOptocoupler coilAOpto;
    DualChannelOptocoupler coilBOpto;
    int stepSequence[4][2] = {
        {HIGH, LOW},
        {LOW, HIGH},
        {LOW, HIGH},
        {HIGH, LOW}
    };
    int currentStep;
    int stepsPerRevolution;
    
public:
    IsolatedStepperDriver(
        // Coil A
        int aCh1In, int aCh1Out,
        int aCh2In, int aCh2Out,
        // Coil B
        int bCh1In, int bCh1Out,
        int bCh2In, int bCh2Out,
        int steps = 200
    ) : coilAOpto(aCh1In, aCh1Out, aCh2In, aCh2Out),
        coilBOpto(bCh1In, bCh1Out, bCh2In, bCh2Out) {
        
        currentStep = 0;
        stepsPerRevolution = steps;
        
        coilAOpto.synchronizeChannels(true);
        coilBOpto.synchronizeChannels(true);
    }
    
    void step(int direction) {
        // direction: 1 برای جلو، -1 برای عقب
        currentStep = (currentStep + direction + 4) % 4;
        
        coilAOpto.setBothChannels(
            stepSequence[currentStep][0],
            stepSequence[currentStep][0]
        );
        
        coilBOpto.setBothChannels(
            stepSequence[currentStep][1],
            stepSequence[currentStep][1]
        );
    }
    
    void stepAngle(float angle) {
        int stepsNeeded = (angle / 360.0) * stepsPerRevolution;
        
        for (int i = 0; i < abs(stepsNeeded); i++) {
            step(stepsNeeded > 0 ? 1 : -1);
            delay(10); // زمان بین استپ‌ها
        }
    }
    
    void microstep(int microstepLevel, float current) {
        // میکرواستپینگ با کنترل جریان
        // microstepLevel: 1, 2, 4, 8, 16
        // current: جریان نسبی (0.0 تا 1.0)
        
        for (int i = 0; i < microstepLevel; i++) {
            float angle = (2 * PI * i) / microstepLevel;
            float aCurrent = current * sin(angle);
            float bCurrent = current * cos(angle);
            
            // کنترل PWM بر اساس جریان
            // (پیاده‌سازی بسته به سخت‌افزار)
        }
    }
    
    void enable(bool state) {
        if (!state) {
            coilAOpto.setBothChannels(LOW, LOW);
            coilBOpto.setBothChannels(LOW, LOW);
        }
    }
    
    int getPosition() {
        return currentStep;
    }
    
    float getAngle() {
        return (currentStep * 360.0) / 4.0;
    }
};

void dualChannelCalibration() {
    Serial.println("=== کالیبراسیون اپتوکوپلر دو حالته ===");
    
    // 1. کالیبراسیون CTR تطبیقی
    Serial.println("1. کالیبراسیون CTR تطبیقی:");
    calibrateCTRMatch();
    
    // 2. کالیبراسیون زمان پاسخ
    Serial.println("\n2. کالیبراسیون زمان پاسخ:");
    calibrateResponseTimeMatch();
    
    // 3. کالیبراسیون تطابق کانال‌ها
    Serial.println("\n3. کالیبراسیون تطابق کانال‌ها:");
    calibrateChannelMatching();
    
    // 4. تست ایزولاسیون متقابل
    Serial.println("\n4. تست ایزولاسیون متقابل:");
    testCrossIsolation();
    
    Serial.println("\n✅ کالیبراسیون کامل شد");
}

void calibrateCTRMatch() {
    Serial.println("هدف: تطابق CTR دو کانال");
    
    float ctrValues[2];
    float ctrRatios[5]; // در جریان‌های مختلف
    
    for (int current = 5; current <= 25; current += 5) {
        Serial.print("جریان " + String(current) + "mA: ");
        
        for (int ch = 0; ch < 2; ch++) {
            // تنظیم جریان ورودی
            // (با PWM یا منبع جریان)
            
            // اندازه‌گیری جریان خروجی
            float outputCurrent = measureOutputCurrent(ch);
            ctrValues[ch] = (outputCurrent / current) * 100.0;
        }
        
        float ratio = ctrValues[0] / ctrValues[1];
        ctrRatios[(current/5)-1] = ratio;
        
        Serial.print("CTR1=");
        Serial.print(ctrValues[0], 1);
        Serial.print("%, CTR2=");
        Serial.print(ctrValues[1], 1);
        Serial.print("%, نسبت=");
        Serial.println(ratio, 3);
    }
    
    // تحلیل تطابق
    float avgRatio = 0;
    for (int i = 0; i < 5; i++) avgRatio += ctrRatios[i];
    avgRatio /= 5.0;
    
    Serial.print("نسبت CTR متوسط: ");
    Serial.println(avgRatio, 3);
    
    if (abs(avgRatio - 1.0) > 0.15) {
        Serial.println("⚠️ تطابق CTR ضعیف است");
    }
}

void temperatureStabilityTest() {
    Serial.println("=== تست پایداری دمایی ===");
    Serial.println("تغییرات CTR با دما");
    
    float temperatures[] = {-20, 0, 25, 50, 75, 100}; // °C
    float ctrData[2][6]; // [کانال][دما]
    
    for (int t = 0; t < 6; t++) {
        Serial.print("دما: ");
        Serial.print(temperatures[t]);
        Serial.println("°C");
        
        // تنظیم دمای محیط (در محیط کنترل شده)
        setTestTemperature(temperatures[t]);
        delay(5000); // تثبیت دما
        
        for (int ch = 0; ch < 2; ch++) {
            ctrData[ch][t] = measureCTRAtTemperature(ch, 10.0); // 10mA
        }
        
        Serial.print("  کانال 1 CTR: ");
        Serial.print(ctrData[0][t], 1);
        Serial.print("% | کانال 2 CTR: ");
        Serial.print(ctrData[1][t], 1);
        Serial.println("%");
    }
    
    // تحلیل نتایج
    analyzeTemperatureStability(ctrData, temperatures, 6);
}

class AdvancedSafetyProtection {
private:
    DualChannelOptocoupler opto;
    float maxCurrentPerChannel;
    float maxPowerDissipation;
    unsigned long overcurrentTimer;
    bool safetyEnabled;
    
public:
    AdvancedSafetyProtection(DualChannelOptocoupler& o, float maxCurrent, float maxPower) 
        : opto(o), maxCurrentPerChannel(maxCurrent), maxPowerDissipation(maxPower) {
        
        safetyEnabled = true;
        overcurrentTimer = 0;
    }
    
    bool safeChannelControl(int channel, bool state, float measuredCurrent) {
        if (!safetyEnabled) {
            opto.setChannel(channel, state);
            return true;
        }
        
        // بررسی جریان
        if (measuredCurrent > maxCurrentPerChannel) {
            Serial.print("⚠️ جریان کانال ");
            Serial.print(channel);
            Serial.print(" بیش از حد: ");
            Serial.print(measuredCurrent, 1);
            Serial.println("mA");
            
            if (millis() - overcurrentTimer > 1000) {
                emergencyShutdown();
                return false;
            }
        } else {
            overcurrentTimer = 0;
        }
        
        // بررسی توان تلفاتی
        float power = calculatePowerDissipation(channel, measuredCurrent);
        if (power > maxPowerDissipation) {
            Serial.println("⚠️ توان تلفاتی بیش از حد");
            reduceCurrent(channel);
        }
        
        // کنترل نهایی
        opto.setChannel(channel, state);
        return true;
    }
    
    void emergencyShutdown() {
        Serial.println("🚨 خاموشی اضطراری همه کانال‌ها");
        opto.setBothChannels(LOW, LOW);
        overcurrentTimer = millis();
    }
    
    void enableSafety(bool enable) {
        safetyEnabled = enable;
        Serial.print("حفاظت ایمنی: ");
        Serial.println(enable ? "فعال" : "غیرفعال");
    }
    
    float calculatePowerDissipation(int channel, float current) {
        // محاسبه توان تلفاتی
        float vceSat = 0.3; // ولت (اشباع)
        float vf = 1.2; // ولت (LED)
        
        float powerTransistor = current * vceSat;
        float powerLED = current * vf;
        
        return powerTransistor + powerLED;
    }
    
    void reduceCurrent(int channel) {
        // کاهش جریان با PWM
        Serial.print("کاهش جریان کانال ");
        Serial.println(channel);
        
        // پیاده‌سازی PWM برای کاهش جریان متوسط
        for (int i = 0; i < 10; i++) {
            opto.setChannel(channel, HIGH);
            delayMicroseconds(100);
            opto.setChannel(channel, LOW);
            delayMicroseconds(900);
        }
    }
    
    void runSafetyDiagnostics() {
        Serial.println("=== تست ایمنی ===");
        
        // تست نشتی
        leakageTest();
        
        // تست ایزولاسیون
        isolationTest();
        
        // تست اضافه بار
        overloadTest();
        
        // تست دمایی
        thermalTest();
        
        Serial.println("✅ تست ایمنی کامل شد");
    }
};

void autoDiagnoseDualChannel() {
    Serial.println("=== تشخیص خودکار دو کاناله ===");
    
    // 1. تست LEDها
    Serial.println("1. تست LEDها:");
    testLEDs();
    
    // 2. تست فوتوترانزیستورها
    Serial.println("\n2. تست فوتوترانزیستورها:");
    testPhototransistors();
    
    // 3. تست CTR
    Serial.println("\n3. تست نسبت انتقال:");
    testCTRDual();
    
    // 4. تست ایزولاسیون متقابل
    Serial.println("\n4. تست ایزولاسیون متقابل:");
    testCrossChannelIsolation();
    
    // 5. تست تطابق
    Serial.println("\n5. تست تطابق کانال‌ها:");
    testChannelMatching();
    
    Serial.println("\nتشخیص کامل شد");
    generateDiagnosticReport();
}

void testCrossChannelIsolation() {
    Serial.println("تست نشتی بین کانال‌ها:");
    
    bool leakageDetected = false;
    
    // روشن کردن کانال 1، بررسی کانال 2
    digitalWrite(CH1_INPUT_PIN, HIGH);
    delayMicroseconds(100);
    
    if (digitalRead(CH2_OUTPUT_PIN) == HIGH) {
        Serial.println("❌ نشتی از کانال 1 به کانال 2");
        leakageDetected = true;
    }
    
    digitalWrite(CH1_INPUT_PIN, LOW);
    delayMicroseconds(100);
    
    // روشن کردن کانال 2، بررسی کانال 1
    digitalWrite(CH2_INPUT_PIN, HIGH);
    delayMicroseconds(100);
    
    if (digitalRead(CH1_OUTPUT_PIN) == HIGH) {
        Serial.println("❌ نشتی از کانال 2 به کانال 1");
        leakageDetected = true;
    }
    
    digitalWrite(CH2_INPUT_PIN, LOW);
    
    if (!leakageDetected) {
        Serial.println("✅ ایزولاسیون متقابل صحیح است");
    }
}

class IndustrialControlInterface {
private:
    DualChannelOptocoupler inputIsolator;
    DualChannelOptocoupler outputIsolator;
    bool inputStates[2];
    bool outputStates[2];
    
public:
    IndustrialControlInterface(
        // Input Isolation
        int in1In, int in1Out,
        int in2In, int in2Out,
        // Output Isolation
        int out1In, int out1Out,
        int out2In, int out2Out
    ) : inputIsolator(in1In, in1Out, in2In, in2Out),
        outputIsolator(out1In, out1Out, out2In, out2Out) {
        
        inputStates[0] = inputStates[1] = false;
        outputStates[0] = outputStates[1] = false;
    }
    
    void readIndustrialInputs() {
        inputStates[0] = inputIsolator.getChannelOutput(0);
        inputStates[1] = inputIsolator.getChannelOutput(1);
        
        // تشخیص لبه
        detectEdges();
        
        // فیلتر نویز
        digitalFilter();
    }
    
    void writeIndustrialOutputs(bool out1, bool out2) {
        outputIsolator.setBothChannels(out1, out2);
        outputStates[0] = out1;
        outputStates[1] = out2;
        
        // مانیتور جریان خروجی
        monitorOutputCurrents();
    }
    
    void safetyMonitor() {
        // مانیتور سلامت رابط
        static unsigned long lastCheck = 0;
        if (millis() - lastCheck > 1000) {
            lastCheck = millis();
            
            checkIsolationIntegrity();
            checkThermalStatus();
            checkResponseTimes();
        }
    }
    
    void emergencyStop() {
        outputIsolator.setBothChannels(LOW, LOW);
        Serial.println("🛑 توقف اضطراری صنعتی فعال شد");
    }
};

class PowerInverterInterface {
private:
    DualChannelOptocoupler gateDrivers[3]; // برای 3 فاز
    float switchingFrequency;
    float deadTime;
    
public:
    PowerInverterInterface(float freq = 20000, float deadTimeUs = 2.0) 
        : switchingFrequency(freq), deadTime(deadTimeUs) {
        
        // تنظیم‌های اولیه برای درایور گیت 3 فاز
    }
    
    void generatePWM3Phase(float modulationIndex, float frequency) {
        // تولید PWM سه فاز سینوسی
        for (int phase = 0; phase < 3; phase++) {
            float phaseAngle = (2 * PI * phase) / 3.0;
            generatePhasePWM(phase, modulationIndex, frequency, phaseAngle);
        }
    }
    
    void generatePhasePWM(int phase, float modulationIndex, float frequency, float phaseAngle) {
        unsigned long period = 1000000 / switchingFrequency;
        
        for (int i = 0; i < 100; i++) {
            float time = i / (frequency * 100.0);
            float sineValue = sin(2 * PI * frequency * time + phaseAngle);
            float duty = 0.5 + 0.5 * modulationIndex * sineValue;
            
            unsigned long onTime = period * duty;
            
            // High Side
            gateDrivers[phase].setChannel(0, HIGH);
            delayMicroseconds(onTime);
            gateDrivers[phase].setChannel(0, LOW);
            delayMicroseconds(deadTime);
            
            // Low Side
            gateDrivers[phase].setChannel(1, HIGH);
            delayMicroseconds(period - onTime - deadTime);
            gateDrivers[phase].setChannel(1, LOW);
            delayMicroseconds(deadTime);
        }
    }
    
    void protectFromShootThrough() {
        // جلوگیری از شوت-ترو (همزمانی High و Low)
        for (int phase = 0; phase < 3; phase++) {
            bool highState = gateDrivers[phase].getChannelOutput(0);
            bool lowState = gateDrivers[phase].getChannelOutput(1);
            
            if (highState && lowState) {
                Serial.println("🚨 خطر شوت-ترو تشخیص داده شد");
                emergencyShutdown();
                break;
            }
        }
    }
};