ساختار داخلی:
ورودی → [LED مادون قرمز] → [نور] → [فوتوترانزیستور] → خروجی
  ↓           ↓            ↓           ↓              ↓
سیگنال    فرستنده     محیط عایق     گیرنده       سیگتال
کنترل     نوری        (پلاستیک      نوری          ایزوله
                      یا هوای       (فتوترانزیستور)
                      خشک)

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

// اتصال اپتوکوپلر PC817
#define OPTO_INPUT_PIN  2    // کنترل LED ورودی
#define OPTO_OUTPUT_PIN 3    // خواندن خروجی

// پین‌های اتصال مستقیم (در صورت استفاده بدون ماژول)
#define LED_ANODE_PIN   8    // آند LED
#define LED_CATHODE_PIN 9    // کاتد LED
#define TRANSISTOR_COLLECTOR_PIN 10  // کلکتور
#define TRANSISTOR_EMITTER_PIN   11  // امیتر

void setupOptocoupler() {
    Serial.begin(9600);
    
    // تنظیم پین‌های کنترل
    pinMode(OPTO_INPUT_PIN, OUTPUT);
    pinMode(OPTO_OUTPUT_PIN, INPUT);
    
    // حالت اولیه
    digitalWrite(OPTO_INPUT_PIN, LOW);
    
    Serial.println("ماژول اپتوکوپلر راه‌اندازی شد");
    Serial.println("=============================");
}

void testOptocoupler() {
    // تست عملکرد اپتوکوپلر
    digitalWrite(OPTO_INPUT_PIN, HIGH);  // روشن کردن LED
    delay(10);  // زمان پاسخ
    
    bool outputState = digitalRead(OPTO_OUTPUT_PIN);
    
    Serial.print("ورودی HIGH - خروجی: ");
    Serial.println(outputState ? "HIGH" : "LOW");
    
    digitalWrite(OPTO_INPUT_PIN, LOW);   // خاموش کردن LED
    delay(10);  // زمان پاسخ
    
    outputState = digitalRead(OPTO_OUTPUT_PIN);
    Serial.print("ورودی LOW - خروجی: ");
    Serial.println(outputState ? "HIGH" : "LOW");
}

class SingleChannelOptocoupler {
private:
    int inputPin;
    int outputPin;
    unsigned long responseTime; // میکروثانیه
    bool isInverting; // true برای خروجی معکوس
    float ctr; // Current Transfer Ratio (%)
    
public:
    SingleChannelOptocoupler(int inPin, int outPin, bool invert = false, float ctrValue = 100.0) {
        inputPin = inPin;
        outputPin = outPin;
        isInverting = invert;
        ctr = ctrValue;
        responseTime = 10; // 10µs پیش‌فرض
        
        pinMode(inputPin, OUTPUT);
        pinMode(outputPin, INPUT);
        
        // حالت اولیه
        digitalWrite(inputPin, LOW);
    }
    
    void turnOn() {
        digitalWrite(inputPin, HIGH);
        if (responseTime > 0) {
            delayMicroseconds(responseTime);
        }
    }
    
    void turnOff() {
        digitalWrite(inputPin, LOW);
        if (responseTime > 0) {
            delayMicroseconds(responseTime);
        }
    }
    
    bool getOutputState() {
        bool rawState = digitalRead(outputPin);
        return isInverting ? !rawState : rawState;
    }
    
    bool isIsolated(bool expectedState) {
        // تست ایزولاسیون
        bool currentState = getOutputState();
        
        // خروجی باید معکوس ورودی باشد (در حالت NPN)
        bool inputState = digitalRead(inputPin);
        bool shouldBeActive = (inputState == HIGH && !isInverting) || 
                              (inputState == LOW && isInverting);
        
        return currentState == shouldBeActive;
    }
    
    float calculateCTR() {
        // محاسبه CTR واقعی
        float inputCurrent = measureInputCurrent();
        float outputCurrent = measureOutputCurrent();
        
        if (inputCurrent > 0) {
            return (outputCurrent / inputCurrent) * 100.0;
        }
        return 0.0;
    }
    
    void setResponseTime(unsigned long timeUs) {
        responseTime = timeUs;
        Serial.print("زمان پاسخ تنظیم شد: ");
        Serial.print(timeUs);
        Serial.println(" µs");
    }
    
    void pulseTest(unsigned int pulseWidthUs, int count = 10) {
        Serial.println("=== تست پالس ===");
        
        for (int i = 0; i < count; i++) {
            unsigned long startTime = micros();
            
            turnOn();
            bool onState = getOutputState();
            
            delayMicroseconds(pulseWidthUs);
            
            turnOff();
            bool offState = getOutputState();
            
            unsigned long endTime = micros();
            unsigned long actualPulseWidth = endTime - startTime;
            
            Serial.print("پالس ");
            Serial.print(i + 1);
            Serial.print(": عرض ");
            Serial.print(actualPulseWidth);
            Serial.print("µs | خروجی روشن: ");
            Serial.print(onState);
            Serial.print(" | خروجی خاموش: ");
            Serial.println(offState);
            
            delay(100); // فاصله بین پالس‌ها
        }
    }
    
    void measureResponseTimes() {
        Serial.println("=== اندازه‌گیری زمان‌های پاسخ ===");
        
        // زمان روشن شدن
        unsigned long turnOnStart = micros();
        turnOn();
        unsigned long turnOnTime = micros() - turnOnStart;
        
        // زمان خاموش شدن
        unsigned long turnOffStart = micros();
        turnOff();
        unsigned long turnOffTime = micros() - turnOffStart;
        
        Serial.print("Ton: ");
        Serial.print(turnOnTime);
        Serial.print("µs | Toff: ");
        Serial.print(turnOffTime);
        Serial.println("µs");
    }
    
    bool healthCheck() {
        // بررسی سلامت اپتوکوپلر
        bool test1 = isolationTest();
        bool test2 = ctrTest();
        bool test3 = responseTest();
        
        Serial.println("=== بررسی سلامت اپتوکوپلر ===");
        Serial.print("تست ایزولاسیون: ");
        Serial.println(test1 ? "✅ PASS" : "❌ FAIL");
        Serial.print("تست CTR: ");
        Serial.println(test2 ? "✅ PASS" : "❌ FAIL");
        Serial.print("تست پاسخ: ");
        Serial.println(test3 ? "✅ PASS" : "❌ FAIL");
        
        return test1 && test2 && test3;
    }
};

class DigitalIsolator {
private:
    SingleChannelOptocoupler opto;
    bool lastState;
    
public:
    DigitalIsolator(int inPin, int outPin) : opto(inPin, outPin) {
        lastState = false;
    }
    
    void transmit(bool state) {
        if (state != lastState) {
            if (state) {
                opto.turnOn();
            } else {
                opto.turnOff();
            }
            lastState = state;
        }
    }
    
    bool receive() {
        return opto.getOutputState();
    }
    
    void sendPulse(unsigned int durationMs) {
        opto.turnOn();
        delay(durationMs);
        opto.turnOff();
    }
    
    void sendSerialData(const String& data, int baudRate = 9600) {
        int bitTime = 1000000 / baudRate; // میکروثانیه
        
        for (int i = 0; i < data.length(); i++) {
            char c = data.charAt(i);
            
            // Start bit
            opto.turnOff();
            delayMicroseconds(bitTime);
            
            // Data bits (8 bits)
            for (int bit = 0; bit < 8; bit++) {
                bool bitValue = (c >> bit) & 0x01;
                if (bitValue) {
                    opto.turnOn();
                } else {
                    opto.turnOff();
                }
                delayMicroseconds(bitTime);
            }
            
            // Stop bit
            opto.turnOn();
            delayMicroseconds(bitTime * 2); // دو بیت توقف
        }
    }
};

// استفاده برای ایزوله کردن ارتباط سریال
DigitalIsolator serialIsolator(2, 3);

void setup() {
    Serial.begin(9600);
}

void loop() {
    if (Serial.available()) {
        String data = Serial.readString();
        serialIsolator.sendSerialData(data);
    }
}

class ACLoadController {
private:
    SingleChannelOptocoupler opto;
    int triacPin;
    bool zeroCrossingDetected;
    
public:
    ACLoadController(int optoIn, int optoOut, int triac) 
        : opto(optoIn, optoOut), triacPin(triac) {
        zeroCrossingDetected = false;
        pinMode(triacPin, OUTPUT);
        
        // تنظیم وقفه برای تشخیص عبور از صفر
        attachInterrupt(digitalPinToInterrupt(2), zeroCrossingISR, RISING);
    }
    
    static void zeroCrossingISR() {
        // این تابع در عبور از صفر AC فراخوانی می‌شود
        // باید با متغیرهای استاتیک پیاده‌سازی شود
    }
    
    void turnOnAC() {
        // روشن کردن در عبور از صفر
        waitForZeroCrossing();
        digitalWrite(triacPin, HIGH);
        opto.turnOn();
    }
    
    void turnOffAC() {
        // خاموش کردن در عبور از صفر
        waitForZeroCrossing();
        digitalWrite(triacPin, LOW);
        opto.turnOff();
    }
    
    void dimAC(int angle) {
        // دیمر AC با کنترل فاز
        angle = constrain(angle, 0, 180);
        
        waitForZeroCrossing();
        
        // تأخیر بر اساس زاویه فاز
        int delayTime = map(angle, 0, 180, 8000, 0); // میکروثانیه
        delayMicroseconds(delayTime);
        
        // تریگر تریاک
        digitalWrite(triacPin, HIGH);
        opto.turnOn();
        delayMicroseconds(100); // پالس تریگر
        digitalWrite(triacPin, LOW);
        opto.turnOff();
    }
    
    void waitForZeroCrossing() {
        // انتظار برای عبور از صفر
        while (!zeroCrossingDetected) {
            delayMicroseconds(100);
        }
        zeroCrossingDetected = false;
    }
};

class HighVoltageMonitor {
private:
    SingleChannelOptocoupler opto;
    float voltageDividerRatio;
    float referenceVoltage;
    
public:
    HighVoltageMonitor(int optoIn, int optoOut, float ratio, float refVoltage = 5.0)
        : opto(optoIn, optoOut), voltageDividerRatio(ratio), referenceVoltage(refVoltage) {
    }
    
    bool isVoltagePresent(float thresholdVoltage) {
        // تبدیل ولتاژ به سیگنال دیجیتال
        float scaledVoltage = thresholdVoltage / voltageDividerRatio;
        
        // در اینجا از مقایسه‌گر استفاده می‌شود
        // برای سادگی، فرض می‌کنیم ولتاژ بالای آستانه = HIGH
        return opto.getOutputState();
    }
    
    float estimateVoltage() {
        // تخمین ولتاژ بر اساس زمان روشن بودن
        unsigned long onTime = measureOnTime();
        unsigned long period = measurePeriod();
        
        if (period > 0) {
            float dutyCycle = (float)onTime / period * 100.0;
            return dutyCycle * voltageDividerRatio * referenceVoltage / 100.0;
        }
        return 0.0;
    }
    
    void monitorVoltage(float safeThreshold) {
        static unsigned long lastAlert = 0;
        float currentVoltage = estimateVoltage();
        
        if (currentVoltage > safeThreshold) {
            if (millis() - lastAlert > 5000) { // هر 5 ثانیه
                lastAlert = millis();
                Serial.print("⚠️ ولتاژ بالا: ");
                Serial.print(currentVoltage, 1);
                Serial.println("V");
            }
        }
    }
};

// مدار نمونه برای اتصال PC817
/*
مدار پیشنهادی:
ورودی:
  سیگنال → مقاومت 220Ω → پایه 1 (آند)
  GND → پایه 2 (کاتد)

خروجی:
  پایه 4 (کلکتور) → مقاومت بار → Vcc
  پایه 3 (امیتر) → GND
  
  برای خواندن: نقطه بین کلکتور و مقاومت بار به میکروکنترلر
*/

void setupPC817Circuit() {
    Serial.println("مدار PC817 راه‌اندازی شد");
    Serial.println("مقاومت سری LED: 220Ω برای 5V");
    Serial.println("مقاومت بار کلکتور: 10KΩ");
    Serial.println("پیکربندی: خروجی فعال LOW");
}

float calculateLEDResistor(float supplyVoltage, float ledVoltage, float ledCurrent) {
    // محاسبه مقاومت سری LED
    // R = (Vsupply - Vled) / Iled
    return (supplyVoltage - ledVoltage) / ledCurrent;
}

float calculateCollectorResistor(float supplyVoltage, float collectorCurrent) {
    // محاسبه مقاومت بار کلکتور
    // Rc = Vcc / Ic
    return supplyVoltage / collectorCurrent;
}

class IsolatedMotorDriver {
private:
    SingleChannelOptocoupler opto1; // جهت 1
    SingleChannelOptocoupler opto2; // جهت 2
    int motorPin1, motorPin2;
    
public:
    IsolatedMotorDriver(int opto1In, int opto1Out, int opto2In, int opto2Out, int pin1, int pin2)
        : opto1(opto1In, opto1Out), opto2(opto2In, opto2Out) {
        motorPin1 = pin1;
        motorPin2 = pin2;
        
        pinMode(motorPin1, OUTPUT);
        pinMode(motorPin2, OUTPUT);
    }
    
    void forward() {
        opto1.turnOn();
        opto2.turnOff();
        digitalWrite(motorPin1, HIGH);
        digitalWrite(motorPin2, LOW);
    }
    
    void reverse() {
        opto1.turnOff();
        opto2.turnOn();
        digitalWrite(motorPin1, LOW);
        digitalWrite(motorPin2, HIGH);
    }
    
    void stop() {
        opto1.turnOff();
        opto2.turnOff();
        digitalWrite(motorPin1, LOW);
        digitalWrite(motorPin2, LOW);
    }
    
    void brake() {
        opto1.turnOn();
        opto2.turnOn();
        digitalWrite(motorPin1, HIGH);
        digitalWrite(motorPin2, HIGH);
        delay(100); // ترمز کوتاه
        stop();
    }
};

void comprehensiveOptocouplerTest() {
    SingleChannelOptocoupler opto(2, 3);
    
    Serial.println("=== تست جامع اپتوکوپلر ===");
    
    // 1. تست ایزولاسیون
    Serial.println("1. تست ایزولاسیون:");
    testIsolation(opto);
    
    // 2. تست CTR
    Serial.println("n2. تست نسبت انتقال جریان:");
    testCTR(opto);
    
    // 3. تست زمان پاسخ
    Serial.println("n3. تست زمان‌های پاسخ:");
    testResponseTimes(opto);
    
    // 4. تست فرکانس
    Serial.println("n4. تست فرکانس کاری:");
    testFrequencyResponse(opto);
    
    // 5. تست دمایی
    Serial.println("n5. تست پایداری دمایی:");
    testTemperatureStability(opto);
    
    Serial.println("n✅ تست کامل شد");
}

void testIsolation(SingleChannelOptocoupler& opto) {
    // تست مقاومت عایقی (به صورت نسبی)
    bool isolationGood = true;
    
    for (int i = 0; i < 10; i++) {
        // ایجاد نویز روی ورودی
        analogWrite(9, random(0, 255)); // پین مجاور
        
        bool outputState = opto.getOutputState();
        bool inputState = digitalRead(opto.inputPin);
        
        if (inputState == LOW && outputState == HIGH) {
            isolationGood = false;
            Serial.println("❌ نشتی تشخیص داده شد");
            break;
        }
    }
    
    if (isolationGood) {
        Serial.println("✅ ایزولاسیون صحیح است");
    }
}

void calibrateCTR(SingleChannelOptocoupler& opto) {
    Serial.println("کالیبراسیون CTR:");
    
    float inputCurrents[] = {5.0, 10.0, 15.0, 20.0}; // mA
    float ctrValues[4];
    
    for (int i = 0; i < 4; i++) {
        // تنظیم جریان ورودی (با PWM)
        float pwmValue = (inputCurrents[i] / 20.0) * 255.0;
        analogWrite(opto.inputPin, pwmValue);
        delay(100);
        
        // خواندن خروجی
        float outputCurrent = measureOutputCurrent();
        ctrValues[i] = (outputCurrent / inputCurrents[i]) * 100.0;
        
        Serial.print("Iin=");
        Serial.print(inputCurrents[i]);
        Serial.print("mA, CTR=");
        Serial.print(ctrValues[i], 1);
        Serial.println("%");
    }
    
    // محاسبه CTR متوسط
    float avgCTR = 0.0;
    for (int i = 0; i < 4; i++) {
        avgCTR += ctrValues[i];
    }
    avgCTR /= 4.0;
    
    Serial.print("CTR متوسط: ");
    Serial.print(avgCTR, 1);
    Serial.println("%");
    
    digitalWrite(opto.inputPin, LOW);
}

void safetyGuidelines() {
    Serial.println("=== دستورالعمل‌های ایمنی اپتوکوپلر ===");
    Serial.println("1. همیشه از مقاومت سری برای LED استفاده کنید");
    Serial.println("2. از عبور جریان بیش از حد مجاز خودداری کنید");
    Serial.println("3. اطمینان از قطبیت صحیح اتصالات");
    Serial.println("4. استفاده از هیت‌سینک در جریان‌های بالا");
    Serial.println("5. تست ایزولاسیون قبل از استفاده");
    Serial.println("6. رعایت فاصله‌های عایقی در PCB");
}

class ProtectedOptocoupler {
private:
    SingleChannelOptocoupler opto;
    int currentSensePin;
    float maxCurrent;
    
public:
    ProtectedOptocoupler(int inPin, int outPin, int sensePin, float maxCurrentmA)
        : opto(inPin, outPin), maxCurrent(maxCurrentmA) {
        currentSensePin = sensePin;
        pinMode(currentSensePin, INPUT);
    }
    
    bool safeTurnOn() {
        float current = measureCurrent();
        
        if (current > maxCurrent) {
            Serial.println("⚠️ جریان بیش از حد - عملیات لغو شد");
            return false;
        }
        
        opto.turnOn();
        delayMicroseconds(10);
        
        // تأیید روشن شدن
        if (!opto.getOutputState()) {
            Serial.println("⚠️ اپتوکوپلر روشن نشد");
            return false;
        }
        
        return true;
    }
    
    float measureCurrent() {
        // خواندن از سنسور جریان
        int sensorValue = analogRead(currentSensePin);
        float voltage = sensorValue * (5.0 / 1023.0);
        return (voltage - 2.5) / 0.185; // برای ACS712
    }
    
    void emergencyShutdown() {
        opto.turnOff();
        Serial.println("🛑 خاموشی اضطراری فعال شد");
    }
};

void autoDiagnostic() {
    Serial.println("=== تشخیص خودکار خطا ===");
    
    // تست LED
    testLED();
    
    // تست فوتوترانزیستور
    testPhototransistor();
    
    // تست CTR
    testCTRBasic();
    
    // تست ایزولاسیون
    testBasicIsolation();
    
    Serial.println("تشخیص کامل شد");
}

void testLED() {
    Serial.print("تست LED: ");
    
    // روشن کردن LED با جریان کم
    digitalWrite(OPTO_INPUT_PIN, HIGH);
    delay(10);
    
    bool output = digitalRead(OPTO_OUTPUT_PIN);
    
    if (output) {
        Serial.println("✅ سالم");
    } else {
        Serial.println("❌ مشکوک - CTR ممکن است پایین باشد");
    }
    
    digitalWrite(OPTO_INPUT_PIN, LOW);
}

class PLCInputIsolator {
private:
    SingleChannelOptocoupler opto;
    int inputStatus;
    
public:
    PLCInputIsolator(int inPin, int outPin) : opto(inPin, outPin) {
        inputStatus = 0;
    }
    
    int readIsolatedInput() {
        bool state = opto.getOutputState();
        inputStatus = state ? 1 : 0;
        return inputStatus;
    }
    
    void monitorInput(unsigned long debounceTime = 10) {
        static unsigned long lastChange = 0;
        static bool lastState = false;
        
        bool currentState = opto.getOutputState();
        
        if (currentState != lastState) {
            if (millis() - lastChange > debounceTime) {
                lastChange = millis();
                lastState = currentState;
                
                Serial.print("ورودی تغییر کرد: ");
                Serial.println(currentState ? "ACTIVE" : "INACTIVE");
                
                logEvent(currentState);
            }
        }
    }
};

class InverterGateDriver {
private:
    SingleChannelOptocoupler highSideOpto;
    SingleChannelOptocoupler lowSideOpto;
    float deadTime; // میکروثانیه
    
public:
    InverterGateDriver(int highIn, int highOut, int lowIn, int lowOut, float deadTimeUs = 2.0)
        : highSideOpto(highIn, highOut), lowSideOpto(lowIn, lowOut), deadTime(deadTimeUs) {
    }
    
    void drivePWM(float dutyCycle, float frequency) {
        // محاسبه زمان‌های روشن/خاموش
        unsigned long period = 1000000 / frequency; // میکروثانیه
        unsigned long onTime = period * dutyCycle / 100.0;
        unsigned long offTime = period - onTime - (deadTime * 2);
        
        // درایو High Side
        highSideOpto.turnOn();
        delayMicroseconds(onTime);
        highSideOpto.turnOff();
        delayMicroseconds(deadTime);
        
        // درایو Low Side
        lowSideOpto.turnOn();
        delayMicroseconds(offTime);
        lowSideOpto.turnOff();
        delayMicroseconds(deadTime);
    }
    
    void enableBoth() {
        // برای حالت ترمز
        highSideOpto.turnOn();
        lowSideOpto.turnOn();
    }
    
    void disableBoth() {
        highSideOpto.turnOff();
        lowSideOpto.turnOff();
    }
};

class MedicalIsolation {
private:
    SingleChannelOptocoupler opto;
    bool patientConnected;
    
public:
    MedicalIsolation(int inPin, int outPin) : opto(inPin, outPin) {
        patientConnected = false;
    }
    
    bool isPatientConnected() {
        return patientConnected;
    }
    
    void checkIsolationIntegrity() {
        // تست ایزولاسیون برای تجهیزات پزشکی
        float leakageCurrent = measureLeakageCurrent();
        
        if (leakageCurrent > 10.0) { // میکروآمپر
            Serial.println("⚠️ جریان نشتی بیش از حد مجاز پزشکی");
            triggerSafetyShutdown();
        }
    }
    
    float measureLeakageCurrent() {
        // اندازه‌گیری جریان نشتی
        // پیاده‌سازی بسته به مدار
        return 0.0;
    }
    
    void triggerSafetyShutdown() {
        opto.turnOff();
        Serial.println("🚨 سیستم ایزولاسیون پزشکی خاموش شد");
    }
};