پیکربندی برای دو پکیج DIP-8 (مجموعاً 16 پایه):
پکیج 1 (کانال‌های 1-4):
   ┌───┐
 1 │ ● │ 8   پایه 1: آند LED کانال 1
 2 │   │ 7   پایه 2: کاتد LED کانال 1
 3 │   │ 6   پایه 3: آند LED کانال 2
 4 │   │ 5   پایه 4: کاتد LED کانال 2
   └───┘    پایه 5: آند LED کانال 3
            پایه 6: کاتد LED کانال 3
            پایه 7: آند LED کانال 4
            پایه 8: کاتد LED کانال 4

پکیج 2 (کانال‌های 5-8):
   ┌───┐
 1 │ ● │ 8   پایه 1: آند LED کانال 5
 2 │   │ 7   پایه 2: کاتد LED کانال 5
 3 │   │ 6   پایه 3: آند LED کانال 6
 4 │   │ 5   پایه 4: کاتد LED کانال 6
   └───┘    پایه 5: آند LED کانال 7
            پایه 6: کاتد LED کانال 7
            پایه 7: آند LED کانال 8
            پایه 8: کاتد LED کانال 8

کانال 1-4: [LED1-4] → [فوتوترانزیستور1-4]
کانال 5-8: [LED5-8] → [فوتوترانزیستور5-8]
           ↓                  ↓
     ورودی 1-8           خروجی 1-8
     (ایزوله کامل)      (ایزوله کامل)

// تعریف پایه‌های اپتوکوپلر هشت حالته TLP281-8
#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 CH3_INPUT_PIN   6     // کنترل LED کانال 3
#define CH3_OUTPUT_PIN  7     // خواندن خروجی کانال 3
#define CH4_INPUT_PIN   8     // کنترل LED کانال 4
#define CH4_OUTPUT_PIN  9     // خواندن خروجی کانال 4
#define CH5_INPUT_PIN   10    // کنترل LED کانال 5
#define CH5_OUTPUT_PIN  11    // خواندن خروجی کانال 5
#define CH6_INPUT_PIN   12    // کنترل LED کانال 6
#define CH6_OUTPUT_PIN  13    // خواندن خروجی کانال 6
#define CH7_INPUT_PIN   A0    // کنترل LED کانال 7
#define CH7_OUTPUT_PIN  A1    // خواندن خروجی کانال 7
#define CH8_INPUT_PIN   A2    // کنترل LED کانال 8
#define CH8_OUTPUT_PIN  A3    // خواندن خروجی کانال 8

// پین‌های کنترل گروهی
#define GROUP1_ENABLE   14    // فعال‌سازی کانال‌های 1-4
#define GROUP2_ENABLE   15    // فعال‌سازی کانال‌های 5-8
#define MASTER_ENABLE   16    // فعال‌سازی کلی

// تعریف آرایه‌ها برای مدیریت آسان
const int INPUT_PINS[8] = {2, 4, 6, 8, 10, 12, A0, A2};
const int OUTPUT_PINS[8] = {3, 5, 7, 9, 11, 13, A1, A3};

void setupOctalOptocoupler() {
    Serial.begin(115200);
    
    // تنظیم پین‌های کنترل کانال‌ها
    for (int i = 0; i < 8; i++) {
        pinMode(INPUT_PINS[i], OUTPUT);
        pinMode(OUTPUT_PINS[i], INPUT);
        digitalWrite(INPUT_PINS[i], LOW); // حالت اولیه
    }
    
    // تنظیم پین‌های فعال‌سازی
    pinMode(GROUP1_ENABLE, OUTPUT);
    pinMode(GROUP2_ENABLE, OUTPUT);
    pinMode(MASTER_ENABLE, OUTPUT);
    
    digitalWrite(GROUP1_ENABLE, HIGH);
    digitalWrite(GROUP2_ENABLE, HIGH);
    digitalWrite(MASTER_ENABLE, HIGH);
    
    Serial.println("ماژول اپتوکوپلر هشت حالته راه‌اندازی شد");
    Serial.println("========================================");
    
    // تست اولیه همه کانال‌ها
    testAllChannels();
}

void testAllChannels() {
    Serial.println("=== تست اولیه هشت کانال ===");
    
    for (int i = 0; i < 8; i++) {
        Serial.print("تست کانال ");
        Serial.println(i + 1);
        testSingleChannel(i);
    }
    
    // تست گروهی
    Serial.println("تست گروهی:");
    testGroupOperation();
}

void testSingleChannel(int channel) {
    if (channel < 0 || channel >= 8) return;
    
    int inputPin = INPUT_PINS[channel];
    int outputPin = OUTPUT_PINS[channel];
    
    // تست HIGH
    digitalWrite(inputPin, HIGH);
    delayMicroseconds(50);
    bool outputState = digitalRead(outputPin);
    Serial.print("  ورودی HIGH، خروجی: ");
    Serial.println(outputState ? "HIGH" : "LOW");
    
    // تست LOW
    digitalWrite(inputPin, LOW);
    delayMicroseconds(50);
    outputState = digitalRead(outputPin);
    Serial.print("  ورودی LOW، خروجی: ");
    Serial.println(outputState ? "HIGH" : "LOW");
    
    digitalWrite(inputPin, LOW); // بازگشت به حالت اولیه
}

class OctalChannelOptocoupler {
private:
    struct Channel {
        int inputPin;
        int outputPin;
        bool isEnabled;
        bool isInverting;
        unsigned long responseTime;
        float ctr;
        String name;
        bool lastState;
        float currentLimit;
        unsigned long faultTime;
    };
    
    Channel channels[8];
    bool groupEnabled[2]; // دو گروه 4 تایی
    int groupEnablePins[2];
    int masterEnablePin;
    unsigned long channelMask; // ماسک 8 بیتی برای وضعیت کانال‌ها
    float totalPower;
    
public:
    OctalChannelOptocoupler(
        // کانال‌های 1-4
        int ch1In, int ch1Out,
        int ch2In, int ch2Out,
        int ch3In, int ch3Out,
        int ch4In, int ch4Out,
        // کانال‌های 5-8
        int ch5In, int ch5Out,
        int ch6In, int ch6Out,
        int ch7In, int ch7Out,
        int ch8In, int ch8Out,
        // پین‌های کنترل
        int group1En = -1, int group2En = -1,
        int masterEn = -1
    ) {
        // تنظیم کانال‌های 1-4
        setupChannel(0, ch1In, ch1Out, "کانال 1");
        setupChannel(1, ch2In, ch2Out, "کانال 2");
        setupChannel(2, ch3In, ch3Out, "کانال 3");
        setupChannel(3, ch4In, ch4Out, "کانال 4");
        
        // تنظیم کانال‌های 5-8
        setupChannel(4, ch5In, ch5Out, "کانال 5");
        setupChannel(5, ch6In, ch6Out, "کانال 6");
        setupChannel(6, ch7In, ch7Out, "کانال 7");
        setupChannel(7, ch8In, ch8Out, "کانال 8");
        
        // تنظیمات مشترک
        for (int i = 0; i < 8; i++) {
            channels[i].isEnabled = true;
            channels[i].isInverting = false;
            channels[i].responseTime = 10; // µs
            channels[i].ctr = 100.0; // %
            channels[i].lastState = false;
            channels[i].currentLimit = 50.0; // mA
            channels[i].faultTime = 0;
        }
        
        // تنظیم گروه‌ها
        groupEnablePins[0] = group1En;
        groupEnablePins[1] = group2En;
        masterEnablePin = masterEn;
        
        groupEnabled[0] = true;
        groupEnabled[1] = true;
        
        channelMask = 0xFF; // همه کانال‌ها فعال
        totalPower = 0.0;
        
        initializeAllPins();
    }
    
    void setupChannel(int index, int inputPin, int outputPin, String name) {
        channels[index].inputPin = inputPin;
        channels[index].outputPin = outputPin;
        channels[index].name = name;
    }
    
    void initializeAllPins() {
        for (int i = 0; i < 8; i++) {
            pinMode(channels[i].inputPin, OUTPUT);
            pinMode(channels[i].outputPin, INPUT);
            digitalWrite(channels[i].inputPin, LOW);
        }
        
        // تنظیم پین‌های کنترل گروهی
        for (int i = 0; i < 2; i++) {
            if (groupEnablePins[i] != -1) {
                pinMode(groupEnablePins[i], OUTPUT);
                digitalWrite(groupEnablePins[i], HIGH);
            }
        }
        
        if (masterEnablePin != -1) {
            pinMode(masterEnablePin, OUTPUT);
            digitalWrite(masterEnablePin, HIGH);
        }
        
        Serial.println("اپتوکوپلر هشت کاناله آماده است");
        printSystemConfiguration();
    }
    
    void setChannel(int channel, bool state, float measuredCurrent = 0.0) {
        if (channel < 0 || channel >= 8 || !channels[channel].isEnabled) return;
        
        // بررسی محدودیت جریان
        if (measuredCurrent > 0 && measuredCurrent > channels[channel].currentLimit) {
            handleOvercurrent(channel, measuredCurrent);
            return;
        }
        
        // تنظیم حالت
        digitalWrite(channels[channel].inputPin, state ? HIGH : LOW);
        channels[channel].lastState = state;
        
        if (channels[channel].responseTime > 0) {
            delayMicroseconds(channels[channel].responseTime);
        }
        
        updateChannelMask(channel, state);
        
        // محاسبه توان مصرفی
        updatePowerConsumption(channel, state, measuredCurrent);
    }
    
    bool getChannelOutput(int channel) {
        if (channel < 0 || channel >= 8) return false;
        
        bool rawState = digitalRead(channels[channel].outputPin);
        return channels[channel].isInverting ? !rawState : rawState;
    }
    
    void setAllChannels(bool states[8]) {
        unsigned long startTime = micros();
        
        for (int i = 0; i < 8; i++) {
            if (channels[i].isEnabled) {
                digitalWrite(channels[i].inputPin, states[i] ? HIGH : LOW);
                channels[i].lastState = states[i];
                updateChannelMask(i, states[i]);
            }
        }
        
        // انتظار برای آهسته‌ترین کانال
        unsigned long maxResponse = getMaxResponseTime();
        while (micros() - startTime < maxResponse) {
            // انتظار
        }
    }
    
    void setGroup(int group, bool state) {
        if (group < 0 || group >= 2) return;
        
        int startChannel = group * 4;
        int endChannel = startChannel + 4;
        
        for (int i = startChannel; i < endChannel; i++) {
            if (channels[i].isEnabled) {
                setChannel(i, state);
            }
        }
        
        groupEnabled[group] = state;
    }
    
    void setAll(bool state) {
        for (int i = 0; i < 8; i++) {
            if (channels[i].isEnabled) {
                setChannel(i, state);
            }
        }
    }
    
    void toggleChannel(int channel) {
        if (channel >= 0 && channel < 8) {
            setChannel(channel, !channels[channel].lastState);
        }
    }
    
    void toggleAll() {
        for (int i = 0; i < 8; i++) {
            if (channels[i].isEnabled) {
                toggleChannel(i);
            }
        }
    }
    
    void pulseChannel(int channel, unsigned long durationUs) {
        setChannel(channel, HIGH);
        delayMicroseconds(durationUs);
        setChannel(channel, LOW);
    }
    
    void pulseAll(unsigned long durationUs) {
        unsigned long startTime = micros();
        setAll(true);
        
        while (micros() - startTime < durationUs) {
            // انتظار
        }
        
        setAll(false);
    }
    
    void enableChannel(int channel, bool enable) {
        if (channel >= 0 && channel < 8) {
            channels[channel].isEnabled = enable;
            
            if (!enable) {
                setChannel(channel, LOW);
            }
            
            Serial.print(channels[channel].name);
            Serial.println(enable ? " فعال شد" : " غیرفعال شد");
        }
    }
    
    void enableGroup(int group, bool enable) {
        if (group >= 0 && group < 2) {
            groupEnabled[group] = enable;
            
            if (groupEnablePins[group] != -1) {
                digitalWrite(groupEnablePins[group], enable ? HIGH : LOW);
            }
            
            int startChannel = group * 4;
            for (int i = startChannel; i < startChannel + 4; i++) {
                channels[i].isEnabled = enable;
            }
            
            Serial.print("گروه ");
            Serial.print(group + 1);
            Serial.println(enable ? " فعال شد" : " غیرفعال شد");
        }
    }
    
    void enableAll(bool enable) {
        if (masterEnablePin != -1) {
            digitalWrite(masterEnablePin, enable ? HIGH : LOW);
        }
        
        for (int i = 0; i < 2; i++) {
            enableGroup(i, enable);
        }
        
        Serial.print("سیستم کامل ");
        Serial.println(enable ? "فعال شد" : "غیرفعال شد");
    }
    
    void setResponseTime(int channel, unsigned long timeUs) {
        if (channel >= 0 && channel < 8) {
            channels[channel].responseTime = timeUs;
        }
    }
    
    void setAllResponseTimes(unsigned long timeUs) {
        for (int i = 0; i < 8; i++) {
            channels[i].responseTime = timeUs;
        }
    }
    
    unsigned long getMaxResponseTime() {
        unsigned long maxTime = 0;
        for (int i = 0; i < 8; i++) {
            if (channels[i].responseTime > maxTime) {
                maxTime = channels[i].responseTime;
            }
        }
        return maxTime;
    }
    
    void updateChannelMask(int channel, bool state) {
        if (state) {
            channelMask |= (1 << channel);
        } else {
            channelMask &= ~(1 << channel);
        }
    }
    
    unsigned long getChannelMask() {
        return channelMask & 0xFF; // 8 بیت
    }
    
    void updatePowerConsumption(int channel, bool state, float current) {
        static float powerPerChannel[8] = {0};
        
        if (state && current > 0) {
            // محاسبه توان (فرض: ولتاژ 5V)
            float power = 5.0 * (current / 1000.0); // وات
            powerPerChannel[channel] = power;
        } else {
            powerPerChannel[channel] = 0;
        }
        
        // محاسبه توان کل
        totalPower = 0;
        for (int i = 0; i < 8; i++) {
            totalPower += powerPerChannel[i];
        }
        
        // بررسی محدودیت توان
        if (totalPower > 1.0) { // 1 وات
            Serial.print("⚠️ توان کل بالا: ");
            Serial.print(totalPower, 2);
            Serial.println("W");
        }
    }
    
    void handleOvercurrent(int channel, float current) {
        Serial.print("🚨 جریان بیش از حد کانال ");
        Serial.print(channel + 1);
        Serial.print(": ");
        Serial.print(current, 1);
        Serial.print("mA (محدودیت: ");
        Serial.print(channels[channel].currentLimit);
        Serial.println("mA)");
        
        channels[channel].faultTime = millis();
        enableChannel(channel, false);
        
        // اگر بیش از 3 کانال خطا داشته باشند، خاموشی کامل
        int faultCount = countFaultyChannels();
        if (faultCount >= 3) {
            emergencyShutdown();
        }
    }
    
    int countFaultyChannels() {
        int count = 0;
        for (int i = 0; i < 8; i++) {
            if (!channels[i].isEnabled && channels[i].faultTime > 0) {
                count++;
            }
        }
        return count;
    }
    
    void emergencyShutdown() {
        Serial.println("🚨🚨🚨 خاموشی اضطراری کامل فعال شد 🚨🚨🚨");
        enableAll(false);
    }
    
    void printSystemConfiguration() {
        Serial.println("=== پیکربندی سیستم هشت کاناله ===");
        Serial.println("کانال | فعال | معکوس | زمان پاسخ | محدودیت جریان");
        Serial.println("------|-------|--------|-----------|--------------");
        
        for (int i = 0; i < 8; i++) {
            Serial.print(channels[i].name);
            Serial.print(" | ");
            Serial.print(channels[i].isEnabled ? "✓" : "✗");
            Serial.print("     | ");
            Serial.print(channels[i].isInverting ? "✓" : "✗");
            Serial.print("      | ");
            Serial.print(channels[i].responseTime);
            Serial.print("µs    | ");
            Serial.print(channels[i].currentLimit);
            Serial.println("mA");
        }
        
        Serial.print("ماسک کانال‌ها: 0x");
        Serial.println(getChannelMask(), HEX);
        Serial.print("توان مصرفی کل: ");
        Serial.print(totalPower, 2);
        Serial.println("W");
    }
    
    void runComprehensiveDiagnostics() {
        Serial.println("=== تست تشخیصی جامع هشت کاناله ===");
        
        // 1. تست عملکرد پایه
        Serial.println("\n1. تست عملکرد پایه:");
        basicFunctionTest();
        
        // 2. تست زمان پاسخ
        Serial.println("\n2. تست زمان‌های پاسخ:");
        responseTimeTest();
        
        // 3. تست ایزولاسیون
        Serial.println("\n3. تست ایزولاسیون:");
        isolationTest();
        
        // 4. تست تطابق کانال‌ها
        Serial.println("\n4. تست تطابق کانال‌ها:");
        channelMatchingTest();
        
        // 5. تست بارگذاری
        Serial.println("\n5. تست بارگذاری:");
        loadingTest();
        
        // 6. تست حرارتی
        Serial.println("\n6. تست حرارتی:");
        thermalTest();
        
        Serial.println("\n✅ تست تشخیصی کامل شد");
        generateDiagnosticReport();
    }
};

class IndustrialPLC8Channel {
private:
    OctalChannelOptocoupler inputModule;
    OctalChannelOptocoupler outputModule;
    bool inputStates[8];
    bool outputStates[8];
    unsigned long debounceTimes[8];
    float inputCurrents[8];
    float outputCurrents[8];
    
public:
    IndustrialPLC8Channel(
        // Input Module
        int in1In, int in1Out,
        int in2In, int in2Out,
        int in3In, int in3Out,
        int in4In, int in4Out,
        int in5In, int in5Out,
        int in6In, int in6Out,
        int in7In, int in7Out,
        int in8In, int in8Out,
        // Output Module
        int out1In, int out1Out,
        int out2In, int out2Out,
        int out3In, int out3Out,
        int out4In, int out4Out,
        int out5In, int out5Out,
        int out6In, int out6Out,
        int out7In, int out7Out,
        int out8In, int out8Out
    ) : inputModule(in1In, in1Out, in2In, in2Out, in3In, in3Out, in4In, in4Out,
                    in5In, in5Out, in6In, in6Out, in7In, in7Out, in8In, in8Out),
        outputModule(out1In, out1Out, out2In, out2Out, out3In, out3Out, out4In, out4Out,
                     out5In, out5Out, out6In, out6Out, out7In, out7Out, out8In, out8Out) {
        
        for (int i = 0; i < 8; i++) {
            inputStates[i] = false;
            outputStates[i] = false;
            debounceTimes[i] = 20; // ms
            inputCurrents[i] = 0.0;
            outputCurrents[i] = 0.0;
        }
        
        Serial.println("سیستم PLC هشت کاناله صنعتی راه‌اندازی شد");
    }
    
    void scanInputs() {
        static bool lastStates[8] = {false};
        static unsigned long lastChangeTime[8] = {0};
        
        for (int i = 0; i < 8; i++) {
            bool currentState = inputModule.getChannelOutput(i);
            float current = readInputCurrent(i); // از سنسور جریان
            
            inputCurrents[i] = current;
            
            // تشخیص تغییر با دبنانس
            if (currentState != lastStates[i]) {
                unsigned long currentTime = millis();
                
                if (currentTime - lastChangeTime[i] > debounceTimes[i]) {
                    lastChangeTime[i] = currentTime;
                    lastStates[i] = currentState;
                    inputStates[i] = currentState;
                    
                    processInputChange(i, currentState, current);
                }
            }
        }
    }
    
    void writeOutputs(bool states[8], float currents[8]) {
        for (int i = 0; i < 8; i++) {
            outputModule.setChannel(i, states[i], currents[i]);
            outputStates[i] = states[i];
            outputCurrents[i] = currents[i];
        }
        
        logOutputActivity();
    }
    
    void writeOutput(int channel, bool state, float current = 0.0) {
        if (channel >= 0 && channel < 8) {
            outputModule.setChannel(channel, state, current);
            outputStates[channel] = state;
            outputCurrents[channel] = current;
            
            Serial.print("خروجی ");
            Serial.print(channel + 1);
            Serial.print(" تنظیم شد: ");
            Serial.print(state ? "ON" : "OFF");
            Serial.print(" (");
            Serial.print(current, 1);
            Serial.println("mA)");
        }
    }
    
    void processInputChange(int channel, bool state, float current) {
        Serial.print("ورودی ");
        Serial.print(channel + 1);
        Serial.print(" تغییر کرد: ");
        Serial.print(state ? "ACTIVE" : "INACTIVE");
        Serial.print(" (");
        Serial.print(current, 1);
        Serial.println("mA)");
        
        // منطق کنترل PLC
        switch(channel) {
            case 0: // Emergency Stop
                if (state) emergencyStop();
                break;
                
            case 1: // Start Process
                if (state) startManufacturingProcess();
                break;
                
            case 2: // Stop Process
                if (state) stopManufacturingProcess();
                break;
                
            case 3: // Reset System
                if (state) resetControlSystem();
                break;
                
            case 4: // Safety Door
                if (!state) safetyDoorOpen();
                break;
                
            case 5: // Pressure Sensor
                monitorPressure(state, current);
                break;
                
            case 6: // Temperature Sensor
                monitorTemperature(state, current);
                break;
                
            case 7: // Level Sensor
                monitorLevel(state, current);
                break;
        }
    }
    
    void emergencyStop() {
        Serial.println("🚨 توقف اضطراری صنعتی فعال شد");
        
        // خاموش کردن همه خروجی‌ها
        bool offStates[8] = {false, false, false, false, false, false, false, false};
        float zeroCurrents[8] = {0, 0, 0, 0, 0, 0, 0, 0};
        
        writeOutputs(offStates, zeroCurrents);
        
        // فعال کردن آلارم
        triggerEmergencyAlarm();
        
        // لاگ رویداد
        logEmergencyEvent();
    }
    
    void monitorSystemHealth() {
        static unsigned long lastHealthCheck = 0;
        if (millis() - lastHealthCheck > 5000) { // هر 5 ثانیه
            lastHealthCheck = millis();
            
            // بررسی جریان‌های ورودی
            for (int i = 0; i < 8; i++) {
                if (inputCurrents[i] > 25.0) {
                    Serial.print("⚠️ جریان ورودی بالا کانال ");
                    Serial.print(i + 1);
                    Serial.print(": ");
                    Serial.print(inputCurrents[i], 1);
                    Serial.println("mA");
                }
            }
            
            // بررسی جریان‌های خروجی
            for (int i = 0; i < 8; i++) {
                if (outputCurrents[i] > 50.0) {
                    Serial.print("⚠️ جریان خروجی بالا کانال ");
                    Serial.print(i + 1);
                    Serial.print(": ");
                    Serial.print(outputCurrents[i], 1);
                    Serial.println("mA");
                    
                    // کاهش جریان خودکار
                    reduceOutputCurrent(i);
                }
            }
            
            // بررسی دمای سیستم
            checkSystemTemperature();
            
            // بررسی ایزولاسیون
            checkIsolationIntegrity();
        }
    }
    
    void setDebounceTime(int channel, unsigned long timeMs) {
        if (channel >= 0 && channel < 8) {
            debounceTimes[channel] = timeMs;
        }
    }
    
    void runPLCDiagnostics() {
        Serial.println("=== تست تشخیصی PLC صنعتی ===");
        
        // تست ورودی‌ها
        Serial.println("تست ماژول ورودی:");
        testInputModule();
        
        // تست خروجی‌ها
        Serial.println("تست ماژول خروجی:");
        testOutputModule();
        
        // تست ارتباط بین ماژول‌ها
        Serial.println("تست ارتباط ماژول‌ها:");
        testInterModuleCommunication();
        
        // تست سیستم ایمنی
        Serial.println("تست سیستم ایمنی:");
        testSafetySystems();
        
        Serial.println("✅ تست تشخیصی PLC کامل شد");
    }
};

class Industrial8PhaseMotorController {
private:
    OctalChannelOptocoupler gateDrivers;
    int phaseSequence[16][8]; // دنباله ۱۶ مرحله‌ای برای حرکت نرم
    int currentStep;
    int microstepLevel;
    float phaseCurrents[8];
    float maxCurrent;
    bool enabled;
    
public:
    Industrial8PhaseMotorController(
        // پیکربندی ۸ کانال برای ۸ فاز
        int ch1In, int ch1Out,
        int ch2In, int ch2Out,
        int ch3In, int ch3Out,
        int ch4In, int ch4Out,
        int ch5In, int ch5Out,
        int ch6In, int ch6Out,
        int ch7In, int ch7Out,
        int ch8In, int ch8Out,
        float maxCurrentA = 5.0
    ) : gateDrivers(ch1In, ch1Out, ch2In, ch2Out, ch3In, ch3Out, ch4In, ch4Out,
                    ch5In, ch5Out, ch6In, ch6Out, ch7In, ch7Out, ch8In, ch8Out) {
        
        currentStep = 0;
        microstepLevel = 16;
        maxCurrent = maxCurrentA * 1000; // تبدیل به mA
        enabled = false;
        
        // مقداردهی اولیه جریان فازها
        for (int i = 0; i < 8; i++) {
            phaseCurrents[i] = 0.0;
        }
        
        // تولید دنباله سینوسی ۱۶ مرحله‌ای برای ۸ فاز
        generatePhaseSequence();
        
        Serial.println("کنترلر موتور ۸ فاز صنعتی آماده است");
        Serial.print("حداکثر جریان: ");
        Serial.print(maxCurrent);
        Serial.println("mA");
    }
    
    void generatePhaseSequence() {
        // تولید دنباله سینوسی برای حرکت نرم
        for (int step = 0; step < 16; step++) {
            float angle = (2.0 * PI * step) / 16.0;
            
            for (int phase = 0; phase < 8; phase++) {
                float phaseAngle = (2.0 * PI * phase) / 8.0;
                float value = sin(angle - phaseAngle);
                
                // تبدیل به مقدار باینری (برای حالت تمام استپ)
                phaseSequence[step][phase] = (value > 0.5) ? 1 : 
                                            (value < -0.5) ? 0 : 0;
            }
        }
    }
    
    void enable(bool state) {
        enabled = state;
        gateDrivers.enableAll(state);
        
        Serial.print("درایور موتور ");
        Serial.println(state ? "فعال شد" : "غیرفعال شد");
    }
    
    void step(int direction, int speedRPM = 60) {
        if (!enabled) return;
        
        // محاسبه تأخیر بر اساس سرعت
        float stepsPerSecond = (speedRPM * microstepLevel * 16) / 60.0;
        unsigned long stepDelay = 1000000 / stepsPerSecond; // میکروثانیه
        
        // حرکت به مرحله بعدی
        currentStep = (currentStep + direction + 16) % 16;
        
        // اعمال دنباله فازها
        applyPhaseSequence(currentStep);
        
        // تأخیر برای کنترل سرعت
        delayMicroseconds(stepDelay);
        
        // به‌روزرسانی موقعیت
        updatePosition(direction);
        
        // مانیتور جریان
        monitorPhaseCurrents();
    }
    
    void applyPhaseSequence(int step) {
        bool states[8];
        float currents[8];
        
        for (int phase = 0; phase < 8; phase++) {
            states[phase] = (phaseSequence[step][phase] == 1);
            
            // محاسبه جریان سینوسی برای میکرواستپ
            if (microstepLevel > 1) {
                float angle = (2.0 * PI * step) / (16.0 * microstepLevel);
                float phaseAngle = (2.0 * PI * phase) / 8.0;
                float sinValue = sin(angle - phaseAngle);
                
                // محدود کردن جریان
                currents[phase] = abs(sinValue) * (maxCurrent / 2.0);
                phaseCurrents[phase] = currents[phase];
            } else {
                currents[phase] = states[phase] ? maxCurrent : 0;
                phaseCurrents[phase] = currents[phase];
            }
        }
        
        // اعمال به درایور
        for (int i = 0; i < 8; i++) {
            gateDrivers.setChannel(i, states[i], currents[i]);
        }
    }
    
    void microstep(int microstepIndex, int direction) {
        if (!enabled) return;
        
        // محاسبه زاویه میکرواستپ
        float angle = (2.0 * PI * microstepIndex) / (microstepLevel * 16);
        
        bool states[8];
        float currents[8];
        
        for (int phase = 0; phase < 8; phase++) {
            float phaseAngle = (2.0 * PI * phase) / 8.0;
            float sinValue = sin(angle - phaseAngle);
            
            // تبدیل به PWM
            states[phase] = (sinValue > 0);
            currents[phase] = abs(sinValue) * (maxCurrent / 2.0);
            phaseCurrents[phase] = currents[phase];
        }
        
        // اعمال میکرواستپ
        for (int i = 0; i < 8; i++) {
            gateDrivers.setChannel(i, states[i], currents[i]);
        }
    }
    
    void updatePosition(int direction) {
        static float position = 0.0;
        float stepAngle = 360.0 / (16.0 * microstepLevel);
        position += direction * stepAngle;
        
        // نرمال‌سازی
        while (position >= 360.0) position -= 360.0;
        while (position < 0.0) position += 360.0;
    }
    
    void monitorPhaseCurrents() {
        static unsigned long lastCheck = 0;
        if (millis() - lastCheck > 100) { // هر 100ms
            lastCheck = millis();
            
            float totalCurrent = 0;
            for (int i = 0; i < 8; i++) {
                totalCurrent += phaseCurrents[i];
                
                // بررسی جریان بیش از حد در هر فاز
                if (phaseCurrents[i] > maxCurrent * 0.8) {
                    Serial.print("⚠️ جریان بالا فاز ");
                    Serial.print(i + 1);
                    Serial.print(": ");
                    Serial.print(phaseCurrents[i], 1);
                    Serial.println("mA");
                }
            }
            
            // بررسی جریان کل
            if (totalCurrent > maxCurrent * 4) { // ۴ فاز فعال
                Serial.print("⚠️ جریان کل بالا: ");
                Serial.print(totalCurrent, 1);
                Serial.println("mA");
                
                reduceCurrentAutomatically();
            }
        }
    }
    
    void reduceCurrentAutomatically() {
        // کاهش خودکار جریان برای جلوگیری از اضافه بار
        Serial.println("کاهش خودکار جریان فعال شد");
        
        for (int i = 0; i < 8; i++) {
            phaseCurrents[i] *= 0.8; // کاهش 20%
        }
    }
    
    void moveToAngle(float targetAngle, float speedRPM = 30) {
        Serial.print("حرکت به زاویه: ");
        Serial.print(targetAngle, 1);
        Serial.println(" درجه");
        
        float currentAngle = 0; // باید از موقعیت فعلی خوانده شود
        float angleDiff = targetAngle - currentAngle;
        
        // محاسبه کوتاه‌ترین مسیر
        if (angleDiff > 180.0) angleDiff -= 360.0;
        if (angleDiff < -180.0) angleDiff += 360.0;
        
        int stepsNeeded = (angleDiff / 360.0) * (16 * microstepLevel);
        int direction = (stepsNeeded > 0) ? 1 : -1;
        stepsNeeded = abs(stepsNeeded);
        
        Serial.print("نیاز به ");
        Serial.print(stepsNeeded);
        Serial.println(" میکرواستپ");
        
        // اجرای حرکت
        for (int i = 0; i < stepsNeeded; i++) {
            int microstepIndex = (currentStep * microstepLevel + i * direction) % (16 * microstepLevel);
            microstep(microstepIndex, direction);
            
            // کنترل سرعت
            delay(60000 / (speedRPM * 16 * microstepLevel)); // ms
        }
        
        Serial.println("✅ حرکت کامل شد");
    }
    
    void runMotorTest() {
        Serial.println("=== تست موتور ۸ فاز ===");
        
        enable(true);
        
        // تست حرکت در سرعت‌های مختلف
        float speeds[] = {10, 30, 60, 90, 120};
        
        for (int s = 0; s < 5; s++) {
            Serial.print("تست سرعت: ");
            Serial.print(speeds[s]);
            Serial.println(" RPM");
            
            // حرکت 10 دور کامل
            for (int rev = 0; rev < 10; rev++) {
                for (int step = 0; step < 16 * microstepLevel; step++) {
                    step(1, speeds[s]);
                }
            }
            
            // معکوس
            for (int rev = 0; rev < 10; rev++) {
                for (int step = 0; step < 16 * microstepLevel; step++) {
                    step(-1, speeds[s]);
                }
            }
        }
        
        enable(false);
        Serial.println("✅ تست موتور کامل شد");
    }
};

class IndustrialEthernetInterface {
private:
    OctalChannelOptocoupler dataBus;
    OctalChannelOptocoupler controlBus;
    int addressPins[3];
    int chipSelectPin;
    int readWritePin;
    int dataBuffer[8];
    bool busDirection; // true = نوشتن, false = خواندن
    
public:
    IndustrialEthernetInterface(
        // Data Bus (8-bit)
        int d0In, int d0Out,
        int d1In, int d1Out,
        int d2In, int d2Out,
        int d3In, int d3Out,
        int d4In, int d4Out,
        int d5In, int d5Out,
        int d6In, int d6Out,
        int d7In, int d7Out,
        // Control Bus
        int addr0, int addr1, int addr2,
        int csPin, int rwPin
    ) : dataBus(d0In, d0Out, d1In, d1Out, d2In, d2Out, d3In, d3Out,
                d4In, d4Out, d5In, d5Out, d6In, d6Out, d7In, d7Out) {
        
        addressPins[0] = addr0;
        addressPins[1] = addr1;
        addressPins[2] = addr2;
        chipSelectPin = csPin;
        readWritePin = rwPin;
        busDirection = false; // حالت خواندن پیش‌فرض
        
        // تنظیم پین‌های آدرس و کنترل
        for (int i = 0; i < 3; i++) {
            pinMode(addressPins[i], OUTPUT);
        }
        pinMode(chipSelectPin, OUTPUT);
        pinMode(readWritePin, OUTPUT);
        
        // حالت اولیه
        digitalWrite(chipSelectPin, HIGH); // غیرفعال
        digitalWrite(readWritePin, HIGH); // خواندن
        
        Serial.println("رابط Industrial Ethernet آماده است");
    }
    
    void setAddress(int address) {
        if (address >= 0 && address < 8) {
            for (int i = 0; i < 3; i++) {
                digitalWrite(addressPins[i], (address >> i) & 0x01);
            }
            
            Serial.print("آدرس تنظیم شد: ");
            Serial.println(address);
        }
    }
    
    void writeData(byte data) {
        busDirection = true;
        digitalWrite(readWritePin, LOW); // حالت نوشتن
        digitalWrite(chipSelectPin, LOW); // فعال
        
        // تبدیل بایت به 8 بیت
        bool bits[8];
        for (int i = 0; i < 8; i++) {
            bits[i] = (data >> i) & 0x01;
        }
        
        // نوشتن روی باس داده
        dataBus.setAllChannels(bits);
        
        delayMicroseconds(10); // زمان استقرار
        
        digitalWrite(chipSelectPin, HIGH); // غیرفعال
        
        Serial.print("نوشتن داده: 0x");
        Serial.println(data, HEX);
    }
    
    byte readData() {
        busDirection = false;
        digitalWrite(readWritePin, HIGH); // حالت خواندن
        digitalWrite(chipSelectPin, LOW); // فعال
        
        delayMicroseconds(10); // زمان استقرار
        
        // خواندن 8 بیت
        byte data = 0;
        for (int i = 0; i < 8; i++) {
            bool bit = dataBus.getChannelOutput(i);
            if (bit) {
                data |= (1 << i);
            }
        }
        
        digitalWrite(chipSelectPin, HIGH); // غیرفعال
        
        Serial.print("خواندن داده: 0x");
        Serial.println(data, HEX);
        
        return data;
    }
    
    void writePacket(const byte* packet, int length) {
        Serial.print("ارسال بسته (");
        Serial.print(length);
        Serial.println(" بایت):");
        
        for (int i = 0; i < length; i++) {
            writeData(packet[i]);
            delayMicroseconds(5);
        }
        
        Serial.println("✅ ارسال کامل شد");
    }
    
    void readPacket(byte* buffer, int length) {
        Serial.print("دریافت بسته (");
        Serial.print(length);
        Serial.println(" بایت):");
        
        for (int i = 0; i < length; i++) {
            buffer[i] = readData();
            delayMicroseconds(5);
        }
        
        Serial.println("✅ دریافت کامل شد");
    }
    
    void sendEthernetFrame(const byte* destMAC, const byte* srcMAC, 
                          const byte* data, int dataLength) {
        // ساخت فریم اترنت ساده
        byte frame[14 + dataLength]; // 14 بایت هدر + داده
        
        // کپی MAC مقصد
        memcpy(frame, destMAC, 6);
        
        // کپی MAC مبدأ
        memcpy(frame + 6, srcMAC, 6);
        
        // نوع فریم (0x0800 = IPv4)
        frame[12] = 0x08;
        frame[13] = 0x00;
        
        // کپی داده
        memcpy(frame + 14, data, dataLength);
        
        // ارسال فریم
        writePacket(frame, 14 + dataLength);
    }
    
    void receiveEthernetFrame(byte* buffer, int maxLength) {
        // دریافت فریم اترنت
        readPacket(buffer, maxLength);
        
        // تجزیه فریم
        byte destMAC[6], srcMAC[6];
        memcpy(destMAC, buffer, 6);
        memcpy(srcMAC, buffer + 6, 6);
        
        uint16_t etherType = (buffer[12] << 8) | buffer[13];
        
        Serial.println("فریم اترنت دریافت شد:");
        Serial.print("  MAC مقصد: ");
        printMAC(destMAC);
        Serial.print("  MAC مبدأ: ");
        printMAC(srcMAC);
        Serial.print("  EtherType: 0x");
        Serial.println(etherType, HEX);
    }
    
    void printMAC(const byte* mac) {
        for (int i = 0; i < 6; i++) {
            if (mac[i] < 0x10) Serial.print("0");
            Serial.print(mac[i], HEX);
            if (i < 5) Serial.print(":");
        }
        Serial.println();
    }
    
    void runCommunicationTest() {
        Serial.println("=== تست ارتباط Industrial Ethernet ===");
        
        // تست نوشتن/خواندن
        byte testData = 0xAA;
        writeData(testData);
        byte received = readData();
        
        if (testData == received) {
            Serial.println("✅ تست باس داده موفق");
        } else {
            Serial.println("❌ تست باس داده ناموفق");
        }
        
        // تست آدرس‌دهی
        for (int addr = 0; addr < 8; addr++) {
            setAddress(addr);
            delay(10);
        }
        
        // تست بسته
        byte testPacket[] = {0x01, 0x02, 0x03, 0x04, 0x05};
        byte receiveBuffer[5];
        
        writePacket(testPacket, 5);
        readPacket(receiveBuffer, 5);
        
        if (memcmp(testPacket, receiveBuffer, 5) == 0) {
            Serial.println("✅ تست بسته موفق");
        } else {
            Serial.println("❌ تست بسته ناموفق");
        }
        
        Serial.println("✅ تست ارتباط کامل شد");
    }
};

class Matrix4x2Configuration {
private:
    OctalChannelOptocoupler& opto;
    bool matrixMode;
    int rows;
    int cols;
    
public:
    Matrix4x2Configuration(OctalChannelOptocoupler& o) : opto(o) {
        matrixMode = false;
        rows = 4;
        cols = 2;
    }
    
    void enableMatrixMode(bool enable) {
        matrixMode = enable;
        
        if (matrixMode) {
            Serial.println("حالت ماتریسی 4×2 فعال شد");
            Serial.println("8 کانال به صورت 4 ردیف و 2 ستون پیکربندی می‌شوند");
        } else {
            Serial.println("حالت عادی فعال شد");
        }
    }
    
    void setMatrixCell(int row, int col, bool state) {
        if (matrixMode && row >= 0 && row < rows && col >= 0 && col < cols) {
            int channel = row * cols + col;
            opto.setChannel(channel, state);
            
            Serial.print("سلول [");
            Serial.print(row);
            Serial.print(",");
            Serial.print(col);
            Serial.print("] تنظیم شد: ");
            Serial.println(state ? "ON" : "OFF");
        }
    }
    
    bool getMatrixCell(int row, int col) {
        if (matrixMode && row >= 0 && row < rows && col >= 0 && col < cols) {
            int channel = row * cols + col;
            return opto.getChannelOutput(channel);
        }
        return false;
    }
    
    void scanRow(int row) {
        if (!matrixMode || row < 0 || row >= rows) return;
        
        Serial.print("اسکن ردیف ");
        Serial.println(row);
        
        for (int col = 0; col < cols; col++) {
            bool state = getMatrixCell(row, col);
            
            Serial.print("  ستون ");
            Serial.print(col);
            Serial.print(": ");
            Serial.println(state ? "ON" : "OFF");
        }
    }
    
    void scanColumn(int col) {
        if (!matrixMode || col < 0 || col >= cols) return;
        
        Serial.print("اسکن ستون ");
        Serial.println(col);
        
        for (int row = 0; row < rows; row++) {
            bool state = getMatrixCell(row, col);
            
            Serial.print("  ردیف ");
            Serial.print(row);
            Serial.print(": ");
            Serial.println(state ? "ON" : "OFF");
        }
    }
    
    void matrixDemoPattern() {
        if (!matrixMode) return;
        
        Serial.println("الگوی نمایش ماتریس:");
        
        // الگوی مارپیچ
        for (int pattern = 0; pattern < 4; pattern++) {
            clearMatrix();
            
            switch(pattern) {
                case 0: // ردیف‌ها
                    for (int row = 0; row < rows; row++) {
                        for (int col = 0; col < cols; col++) {
                            setMatrixCell(row, col, true);
                        }
                        delay(200);
                        clearMatrix();
                    }
                    break;
                    
                case 1: // ستون‌ها
                    for (int col = 0; col < cols; col++) {
                        for (int row = 0; row < rows; row++) {
                            setMatrixCell(row, col, true);
                        }
                        delay(200);
                        clearMatrix();
                    }
                    break;
                    
                case 2: // مورب
                    for (int i = 0; i < min(rows, cols); i++) {
                        setMatrixCell(i, i, true);
                    }
                    delay(500);
                    clearMatrix();
                    break;
                    
                case 3: // همه
                    for (int row = 0; row < rows; row++) {
                        for (int col = 0; col < cols; col++) {
                            setMatrixCell(row, col, true);
                        }
                    }
                    delay(500);
                    clearMatrix();
                    break;
            }
        }
    }
    
    void clearMatrix() {
        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {
                setMatrixCell(row, col, false);
            }
        }
    }
    
    void runMatrixTest() {
        enableMatrixMode(true);
        
        Serial.println("=== تست ماتریس 4×2 ===");
        
        // تست همه سلول‌ها
        for (int row = 0; row < rows; row++) {
            for (int col = 0; col < cols; col++) {
                setMatrixCell(row, col, true);
                delay(100);
                
                bool readBack = getMatrixCell(row, col);
                if (!readBack) {
                    Serial.print("❌ خطا در سلول [");
                    Serial.print(row);
                    Serial.print(",");
                    Serial.print(col);
                    Serial.println("]");
                }
                
                setMatrixCell(row, col, false);
            }
        }
        
        // نمایش الگو
        matrixDemoPattern();
        
        Serial.println("✅ تست ماتریس کامل شد");
    }
};

void industrialOctalCalibration() {
    Serial.println("=== کالیبراسیون صنعتی اپتوکوپلر هشت حالته ===");
    
    OctalChannelOptocoupler opto(2,3,4,5,6,7,8,9,10,11,12,13,A0,A1,A2,A3);
    
    // 1. کالیبراسیون CTR تطبیقی
    Serial.println("1. کالیبراسیون CTR تطبیقی:");
    calibrateOctalCTR(opto);
    
    // 2. کالیبراسیون زمان پاسخ
    Serial.println("\n2. کالیبراسیون زمان پاسخ:");
    calibrateOctalResponseTimes(opto);
    
    // 3. کالیبراسیون تطابق کانال‌ها
    Serial.println("\n3. کالیبراسیون تطابق کانال‌ها:");
    calibrateOctalChannelMatching(opto);
    
    // 4. تست ایزولاسیون متقابل
    Serial.println("\n4. تست ایزولاسیون متقابل:");
    testOctalCrossIsolation(opto);
    
    // 5. تست بارگذاری کامل
    Serial.println("\n5. تست بارگذاری کامل:");
    testOctalLoading(opto);
    
    // 6. تست حرارتی
    Serial.println("\n6. تست پایداری حرارتی:");
    testOctalThermalStability(opto);
    
    Serial.println("\n✅ کالیبراسیون صنعتی کامل شد");
    generateIndustrialCalibrationCertificate();
}

void calibrateOctalCTR(OctalChannelOptocoupler& opto) {
    Serial.println("اندازه‌گیری CTR در ۵ سطح جریان مختلف");
    
    float ctrMatrix[8][5]; // [کانال][جریان]
    float currents[5] = {5, 15, 25, 35, 45}; // mA
    
    for (int c = 0; c < 5; c++) {
        Serial.print("سطح جریان ");
        Serial.print(c + 1);
        Serial.print(": ");
        Serial.print(currents[c]);
        Serial.println("mA");
        
        for (int ch = 0; ch < 8; ch++) {
            // تنظیم دقیق جریان ورودی
            setPrecisionInputCurrent(ch, currents[c]);
            delay(100); // تثبیت
            
            // اندازه‌گیری جریان خروجی با دقت بالا
            float outputCurrent = measurePrecisionOutputCurrent(ch);
            ctrMatrix[ch][c] = (outputCurrent / currents[c]) * 100.0;
            
            // نمایش نتایج
            char buffer[50];
            sprintf(buffer, "  کانال %d: CTR=%5.1f%%", ch + 1, ctrMatrix[ch][c]);
            Serial.println(buffer);
        }
        Serial.println();
    }
    
    // تحلیل آماری نتایج
    performStatisticalAnalysis(ctrMatrix, currents);
    
    // تعیین کانال‌های خارج از محدوده
    identifyOutOfSpecChannels(ctrMatrix);
}

void testOctalCrossIsolation(OctalChannelOptocoupler& opto) {
    Serial.println("تست ایزولاسیون متقابل با ولتاژ بالا");
    
    bool isolationPass = true;
    
    // تست همه ترکیبات کانال‌ها (28 ترکیب)
    for (int activeCh = 0; activeCh < 8; activeCh++) {
        Serial.print("تست با کانال فعال ");
        Serial.println(activeCh + 1);
        
        // اعمال ولتاژ بالا به کانال فعال
        applyHighVoltageToChannel(activeCh, 1000); // 1000V
        delay(100);
        
        for (int testCh = 0; testCh < 8; testCh++) {
            if (testCh != activeCh) {
                float leakageCurrent = measureLeakageCurrent(testCh);
                
                if (leakageCurrent > 1.0) { // بیش از 1μA
                    Serial.print("❌ نشتی قابل توجه از کانال ");
                    Serial.print(activeCh + 1);
                    Serial.print(" به کانال ");
                    Serial.print(testCh + 1);
                    Serial.print(": ");
                    Serial.print(leakageCurrent, 2);
                    Serial.println("μA");
                    
                    isolationPass = false;
                }
            }
        }
        
        removeHighVoltage(activeCh);
        delay(100);
    }
    
    if (isolationPass) {
        Serial.println("✅ ایزولاسیون متقابل در سطح صنعتی صحیح است");
    } else {
        Serial.println("⚠️ نیاز به بررسی ایزولاسیون");
    }
}

void testOctalThermalStability(OctalChannelOptocoupler& opto) {
    Serial.println("تست پایداری حرارتی در محدوده -40°C تا +85°C");
    
    float temperaturePoints[] = {-40, -20, 0, 25, 50, 70, 85};
    int numPoints = sizeof(temperaturePoints) / sizeof(temperaturePoints[0]);
    
    for (int t = 0; t < numPoints; t++) {
        Serial.print("دمای تست: ");
        Serial.print(temperaturePoints[t]);
        Serial.println("°C");
        
        // تنظیم دمای محفظه تست
        setEnvironmentalChamberTemperature(temperaturePoints[t]);
        delay(30000); // 30 ثانیه برای تثبیت
        
        // تست عملکرد در این دما
        bool operational = testOperationAtTemperature(opto, temperaturePoints[t]);
        
        if (!operational) {
            Serial.print("❌ خرابی عملکرد در ");
            Serial.print(temperaturePoints[t]);
            Serial.println("°C");
            break;
        }
        
        // اندازه‌گیری پارامترها
        measureParametersAtTemperature(opto, temperaturePoints[t]);
    }
    
    Serial.println("✅ تست پایداری حرارتی کامل شد");
}

class SIL2SafetyMonitor {
private:
    OctalChannelOptocoupler& opto;
    float safetyThresholds[8];
    unsigned long safetyTimers[8];
    bool safetyStatus[8];
    int redundancyLevel;
    
public:
    SIL2SafetyMonitor(OctalChannelOptocoupler& o, int redundancy = 2) 
        : opto(o), redundancyLevel(redundancy) {
        
        // تنظیم آستانه‌های ایمنی (بر حسب mA)
        float defaultThresholds[] = {45, 45, 45, 45, 45, 45, 45, 45};
        memcpy(safetyThresholds, defaultThresholds, sizeof(defaultThresholds));
        
        for (int i = 0; i < 8; i++) {
            safetyTimers[i] = 0;
            safetyStatus[i] = true;
        }
        
        Serial.println("سیستم مانیتورینگ ایمنی SIL-2 راه‌اندازی شد");
    }
    
    bool safeChannelOperation(int channel, bool requestedState, 
                             float measuredCurrent, float measuredTemperature) {
        if (channel < 0 || channel >= 8) return false;
        
        // 1. بررسی جریان
        if (measuredCurrent > safetyThresholds[channel]) {
            logSafetyEvent(channel, "OVERCURRENT", measuredCurrent);
            
            if (redundancyLevel >= 2) {
                // استفاده از کانال رزرو
                int backupChannel = findBackupChannel(channel);
                if (backupChannel != -1) {
                    switchToBackup(channel, backupChannel);
                    return true;
                }
            }
            
            initiateSafetyShutdown(channel);
            return false;
        }
        
        // 2. بررسی دما
        if (measuredTemperature > 85.0) {
            logSafetyEvent(channel, "OVERTEMPERATURE", measuredTemperature);
            initiateThermalShutdown(channel);
            return false;
        }
        
        // 3. بررسی زمان روشن بودن
        if (requestedState) {
            unsigned long currentTime = millis();
            if (safetyTimers[channel] == 0) {
                safetyTimers[channel] = currentTime;
            } else if (currentTime - safetyTimers[channel] > 3600000) { // 1 ساعت
                logSafetyEvent(channel, "OVERTIME", currentTime - safetyTimers[channel]);
                initiatePreventiveShutdown(channel);
                return false;
            }
        } else {
            safetyTimers[channel] = 0;
        }
        
        // اگر همه چیز OK باشد
        opto.setChannel(channel, requestedState, measuredCurrent);
        safetyStatus[channel] = true;
        
        return true;
    }
    
    void initiateSafetyShutdown(int channel) {
        Serial.print("🚨 آغاز خاموشی ایمنی برای کانال ");
        Serial.println(channel + 1);
        
        safetyStatus[channel] = false;
        opto.enableChannel(channel, false);
        
        // فعال کردن سیستم پشتیبان
        activateBackupSystem();
        
        // ارسال آلارم
        sendSafetyAlert(channel, "SHUTDOWN");
        
        // ثبت در سیستم لاگینگ
        logSafetyShutdown(channel);
    }
    
    void initiateThermalShutdown(int channel) {
        Serial.print("🔥 خاموشی حرارتی برای کانال ");
        Serial.println(channel + 1);
        
        safetyStatus[channel] = false;
        opto.enableChannel(channel, false);
        
        // فعال کردن خنک‌کننده اضطراری
        activateEmergencyCooling();
        
        // کاهش بار سیستم
        reduceSystemLoad();
    }
    
    int findBackupChannel(int faultyChannel) {
        // الگوریتم یافتن کانال رزرو
        for (int i = 0; i < 8; i++) {
            if (i != faultyChannel && safetyStatus[i] && 
                opto.getChannelOutput(i) == false) {
                return i;
            }
        }
        return -1;
    }
    
    void switchToBackup(int faultyChannel, int backupChannel) {
        Serial.print("🔀 تعویض از کانال ");
        Serial.print(faultyChannel + 1);
        Serial.print(" به کانال رزرو ");
        Serial.println(backupChannel + 1);
        
        // کپی وضعیت از کانال معیوب به کانال رزرو
        bool state = opto.getChannelOutput(faultyChannel);
        float current = 0; // باید از سنسور خوانده شود
        
        opto.setChannel(backupChannel, state, current);
        opto.enableChannel(faultyChannel, false);
        
        logRedundancySwitch(faultyChannel, backupChannel);
    }
    
    void runSafetyDiagnostics() {
        Serial.println("=== تست تشخیصی سیستم ایمنی ===");
        
        // تست سیستم رزرو
        testRedundancySystem();
        
        // تست پاسخ‌دهی ایمنی
        testSafetyResponse();
        
        // تست سیستم آلارم
        testAlarmSystem();
        
        // تست سیستم لاگینگ
        testLoggingSystem();
        
        Serial.println("✅ تست سیستم ایمنی کامل شد");
    }
    
    void setSafetyThreshold(int channel, float threshold) {
        if (channel >= 0 && channel < 8) {
            safetyThresholds[channel] = threshold;
            
            Serial.print("آستانه ایمنی کانال ");
            Serial.print(channel + 1);
            Serial.print(" تنظیم شد: ");
            Serial.print(threshold);
            Serial.println("mA");
        }
    }
    
    bool getChannelSafetyStatus(int channel) {
        if (channel >= 0 && channel < 8) {
            return safetyStatus[channel];
        }
        return false;
    }
    
    void printSafetyReport() {
        Serial.println("=== گزارش وضعیت ایمنی ===");
        Serial.println("کانال | وضعیت | آستانه | زمان فعالیت");
        Serial.println("------|--------|---------|------------");
        
        for (int i = 0; i < 8; i++) {
            Serial.print("  ");
            Serial.print(i + 1);
            Serial.print("   | ");
            Serial.print(safetyStatus[i] ? " ایمن " : "خطا  ");
            Serial.print(" | ");
            Serial.print(safetyThresholds[i], 0);
            Serial.print("mA   | ");
            
            if (safetyTimers[i] > 0) {
                unsigned long uptime = (millis() - safetyTimers[i]) / 1000;
                Serial.print(uptime);
                Serial.println("s");
            } else {
                Serial.println("آماده");
            }
        }
    }
};