انکودر نوری:
[دیسک کدگذاری] → [فرستنده LED] → [گیرنده فوتودیود] → [مدار شرط‌سازی]
          ↓                ↓                ↓               ↓
    شیارهای ریز       نور مادون قرمز     تشخیص نور      شکل‌دهی پالس

// تشخیص جهت از فاز کانال‌های A و B
enum Direction {
    CLOCKWISE,      // A leading B
    COUNTER_CLOCKWISE, // B leading A
    UNKNOWN
};

Direction detectDirection(bool channelA, bool channelB, bool lastA, bool lastB) {
    if (lastA == 0 && channelA == 1) { // لبه بالارونده A
        return (channelB == 0) ? CLOCKWISE : COUNTER_CLOCKWISE;
    }
    if (lastB == 0 && channelB == 1) { // لبه بالارونده B
        return (channelA == 1) ? CLOCKWISE : COUNTER_CLOCKWISE;
    }
    return UNKNOWN;
}

// اتصال انکودر افزایشی
#define ENCODER_A 2    // پین با قابلیت وقفه
#define ENCODER_B 3    // پین با قابلیت وقفه
#define ENCODER_Z 4    // پین Index (اختیاری)

volatile long encoderCount = 0;
volatile long lastPosition = 0;
unsigned long lastTime = 0;
float rpm = 0.0;

void setupEncoder() {
    Serial.begin(115200);
    
    // تنظیم پین‌ها
    pinMode(ENCODER_A, INPUT_PULLUP);
    pinMode(ENCODER_B, INPUT_PULLUP);
    pinMode(ENCODER_Z, INPUT_PULLUP);
    
    // تنظیم وقفه‌ها
    attachInterrupt(digitalPinToInterrupt(ENCODER_A), encoderISR, CHANGE);
    attachInterrupt(digitalPinToInterrupt(ENCODER_B), encoderISR, CHANGE);
    
    Serial.println("انکودر چرخشی راه‌اندازی شد");
}

void encoderISR() {
    static uint8_t oldState = 0;
    uint8_t newState = (digitalRead(ENCODER_B) << 1) | digitalRead(ENCODER_A);
    
    // جدول حالت برای انکودر افزایشی
    static const int8_t transitionTable[16] = {
        0,  // 00 -> 00
        -1, // 00 -> 01
        1,  // 00 -> 10
        0,  // 00 -> 11
        1,  // 01 -> 00
        0,  // 01 -> 01
        0,  // 01 -> 10
        -1, // 01 -> 11
        -1, // 10 -> 00
        0,  // 10 -> 01
        0,  // 10 -> 10
        1,  // 10 -> 11
        0,  // 11 -> 00
        1,  // 11 -> 01
        -1, // 11 -> 10
        0   // 11 -> 11
    };
    
    uint8_t index = (oldState << 2) | newState;
    encoderCount += transitionTable[index];
    oldState = newState;
}

class RotaryEncoder {
private:
    int pinA, pinB, pinZ;
    volatile long count;
    volatile long lastCount;
    unsigned long lastTime;
    float velocity; // دور بر دقیقه
    float position; // درجه
    int ppr; // پالس بر دور
    
public:
    RotaryEncoder(int a, int b, int z = -1, int resolution = 1000) {
        pinA = a;
        pinB = b;
        pinZ = z;
        ppr = resolution;
        count = 0;
        velocity = 0.0;
        position = 0.0;
        
        pinMode(pinA, INPUT_PULLUP);
        pinMode(pinB, INPUT_PULLUP);
        if (pinZ != -1) pinMode(pinZ, INPUT_PULLUP);
        
        // وقفه با رزولوشن 4X
        attachInterrupt(digitalPinToInterrupt(pinA), isrA, CHANGE);
        attachInterrupt(digitalPinToInterrupt(pinB), isrB, CHANGE);
    }
    
    // ISR برای کانال A
    static void isrA() {
        static RotaryEncoder* instance = nullptr;
        if (!instance) return;
        
        bool a = digitalRead(instance->pinA);
        bool b = digitalRead(instance->pinB);
        
        if (a == b) {
            instance->count--;
        } else {
            instance->count++;
        }
    }
    
    // ISR برای کانال B
    static void isrB() {
        static RotaryEncoder* encoder = nullptr;
        if (!encoder) return;
        
        bool a = digitalRead(encoder->pinA);
        bool b = digitalRead(encoder->pinB);
        
        if (a == b) {
            encoder->count++;
        } else {
            encoder->count--;
        }
    }
    
    // محاسبه سرعت
    void updateVelocity() {
        unsigned long currentTime = micros();
        if (lastTime == 0) {
            lastTime = currentTime;
            lastCount = count;
            return;
        }
        
        unsigned long deltaTime = currentTime - lastTime;
        long deltaCount = count - lastCount;
        
        if (deltaTime > 0) {
            // محاسبه RPM
            velocity = (deltaCount * 60000000.0) / (ppr * 4 * deltaTime);
            
            // محاسبه موقعیت در درجه
            position = fmod((count * 360.0) / (ppr * 4), 360.0);
            
            lastTime = currentTime;
            lastCount = count;
        }
    }
    
    // گرفتن موقعیت مطلق
    float getAbsolutePosition() {
        return position;
    }
    
    // گرفتن موقعیت نسبی (درصد)
    float getRelativePosition() {
        return fmod(position, 360.0) / 3.6; // درصد
    }
    
    // گرفتن RPM
    float getRPM() {
        return velocity;
    }
    
    // گرفتن سرعت زاویه‌ای (rad/s)
    float getAngularVelocity() {
        return velocity * 0.10472; // RPM به rad/s
    }
    
    // ریست کردن شمارنده
    void reset() {
        count = 0;
        position = 0.0;
        velocity = 0.0;
    }
    
    // تشخیص عبور از نقطه صفر
    bool passedZeroPoint() {
        if (pinZ == -1) return false;
        static bool lastZ = HIGH;
        bool currentZ = digitalRead(pinZ);
        
        if (lastZ == HIGH && currentZ == LOW) {
            lastZ = currentZ;
            return true;
        }
        lastZ = currentZ;
        return false;
    }
};

// استفاده
RotaryEncoder encoder(2, 3, 4, 1000); // 1000 PPR

void setup() {
    Serial.begin(115200);
    Serial.println("انکودر با رزولوشن 1000 PPR راه‌اندازی شد");
}

void loop() {
    encoder.updateVelocity();
    
    static unsigned long lastPrint = 0;
    if (millis() - lastPrint > 100) {
        lastPrint = millis();
        
        Serial.print("موقعیت: ");
        Serial.print(encoder.getAbsolutePosition(), 1);
        Serial.print("° | RPM: ");
        Serial.print(encoder.getRPM(), 1);
        Serial.print(" | سرعت: ");
        Serial.print(encoder.getAngularVelocity(), 2);
        Serial.println(" rad/s");
        
        if (encoder.passedZeroPoint()) {
            Serial.println("📍 عبور از نقطه مرجع");
        }
    }
}

class PositionControlSystem {
private:
    RotaryEncoder encoder;
    float targetPosition;
    float kp, ki, kd;
    float integral, lastError;
    
public:
    PositionControlSystem(int a, int b, float p, float i, float d)
        : encoder(a, b, -1, 2000), kp(p), ki(i), kd(d) {
        targetPosition = 0.0;
        integral = 0.0;
        lastError = 0.0;
    }
    
    void setTarget(float positionDegrees) {
        targetPosition = fmod(positionDegrees, 360.0);
        Serial.print("هدف موقعیت تنظیم شد: ");
        Serial.print(targetPosition);
        Serial.println("°");
    }
    
    float calculateControlOutput() {
        encoder.updateVelocity();
        float currentPosition = encoder.getAbsolutePosition();
        
        // محاسبه خطا
        float error = calculateShortestPathError(currentPosition, targetPosition);
        
        // کنترل PID
        integral += error;
        float derivative = error - lastError;
        
        float output = (kp * error) + (ki * integral) + (kd * derivative);
        
        lastError = error;
        
        // محدود کردن خروجی
        return constrain(output, -100.0, 100.0);
    }
    
    float calculateShortestPathError(float current, float target) {
        float error = target - current;
        
        // پیدا کردن کوتاه‌ترین مسیر دایره‌ای
        if (error > 180.0) {
            error -= 360.0;
        } else if (error < -180.0) {
            error += 360.0;
        }
        
        return error;
    }
    
    bool isPositionReached(float tolerance = 0.5) {
        float error = calculateShortestPathError(
            encoder.getAbsolutePosition(), 
            targetPosition
        );
        return abs(error) < tolerance;
    }
};

class LengthMeasurementSystem {
private:
    RotaryEncoder encoder;
    float wheelDiameter; // قطر غلتک بر حسب mm
    float circumference;
    float totalLength;
    
public:
    LengthMeasurementSystem(int a, int b, float diameter)
        : encoder(a, b, -1, 500), wheelDiameter(diameter) {
        circumference = PI * wheelDiameter;
        totalLength = 0.0;
    }
    
    void update() {
        encoder.updateVelocity();
        
        // محاسبه جابجایی خطی
        float angularChange = encoder.getAngularVelocity() * 0.001; // rad در ms
        float linearDisplacement = (angularChange * wheelDiameter) / 2.0;
        
        totalLength += linearDisplacement;
    }
    
    float getLength() {
        return totalLength;
    }
    
    float getSpeed() {
        return encoder.getAngularVelocity() * wheelDiameter / 2.0;
    }
    
    void resetLength() {
        totalLength = 0.0;
    }
    
    void calibrate(float knownLength) {
        // کالیبراسیون سیستم
        float measuredLength = getLength();
        float correctionFactor = knownLength / measuredLength;
        circumference *= correctionFactor;
        
        Serial.print("کالیبراسیون انجام شد. ضریب اصلاح: ");
        Serial.println(correctionFactor, 4);
    }
};

class ProductionCounter {
private:
    RotaryEncoder encoder;
    int itemsPerRevolution;
    int totalCount;
    int batchCount;
    float thresholdAngle;
    
public:
    ProductionCounter(int a, int b, int itemsPerRev)
        : encoder(a, b, -1, 100), itemsPerRevolution(itemsPerRev) {
        totalCount = 0;
        batchCount = 0;
        thresholdAngle = 360.0 / itemsPerRevolution;
    }
    
    void monitor() {
        static float lastPosition = 0.0;
        encoder.updateVelocity();
        float currentPosition = encoder.getAbsolutePosition();
        
        // محاسبه تغییر موقعیت
        float positionChange = currentPosition - lastPosition;
        if (positionChange < 0) positionChange += 360.0;
        
        // شمارش آیتم‌ها
        int itemsDetected = positionChange / thresholdAngle;
        
        if (itemsDetected > 0) {
            totalCount += itemsDetected;
            batchCount += itemsDetected;
            
            Serial.print("تعداد آیتم: ");
            Serial.print(itemsDetected);
            Serial.print(" | کل تولید: ");
            Serial.println(totalCount);
            
            // بررسی سقف تولید
            if (batchCount >= 1000) {
                Serial.println("🎯 دسته تولید 1000 تایی تکمیل شد");
                batchCount = 0;
            }
        }
        
        lastPosition = currentPosition;
    }
    
    int getTotalCount() { return totalCount; }
    int getBatchCount() { return batchCount; }
    void resetBatch() { batchCount = 0; }
    void resetTotal() { totalCount = 0; }
};

void calibrationRoutine() {
    Serial.println("=== کالیبراسیون انکودر ===");
    
    // 1. کالیبراسیون نقطه صفر
    calibrateZeroPoint();
    
    // 2. کالیبراسیون جهت
    calibrateDirection();
    
    // 3. کالیبراسیون رزولوشن
    calibrateResolution();
    
    // 4. تست خطی بودن
    testLinearity();
    
    Serial.println("کالیبراسیون کامل شد");
}

void calibrateResolution() {
    Serial.println("کالیبراسیون رزولوشن:");
    Serial.println("انکودر را دقیقاً 10 دور بچرخانید...");
    
    long startCount = encoderCount;
    delay(10000); // زمان برای چرخاندن
    
    long endCount = encoderCount;
    long pulsesPer10Rev = endCount - startCount;
    
    float calculatedPPR = pulsesPer10Rev / 40.0; // 4X decoding
    Serial.print("رزولوشن محاسبه شده: ");
    Serial.print(calculatedPPR, 1);
    Serial.println(" PPR");
}

class DigitalFilter {
private:
    float* buffer;
    int size;
    int index;
    float sum;
    
public:
    DigitalFilter(int filterSize) : size(filterSize) {
        buffer = new float[size];
        for (int i = 0; i < size; i++) buffer[i] = 0.0;
        index = 0;
        sum = 0.0;
    }
    
    ~DigitalFilter() {
        delete[] buffer;
    }
    
    float update(float newValue) {
        sum -= buffer[index];
        buffer[index] = newValue;
        sum += newValue;
        
        index = (index + 1) % size;
        return sum / size;
    }
    
    void reset() {
        for (int i = 0; i < size; i++) buffer[i] = 0.0;
        sum = 0.0;
        index = 0;
    }
};

// استفاده
DigitalFilter rpmFilter(10); // فیلتر میانگین متحرک 10 نمونه‌ای

void smoothRPMReading() {
    float rawRPM = encoder.getRPM();
    float filteredRPM = rpmFilter.update(rawRPM);
    
    if (abs(rawRPM - filteredRPM) > 50.0) {
        Serial.println("⚠️ نویز زیاد در خوانش RPM");
    }
}

class BacklashCompensation {
private:
    float backlashAngle; // زاویه لقی مکانیکی
    bool lastDirection;
    float compensation;
    
public:
    BacklashCompensation(float angle) : backlashAngle(angle) {
        lastDirection = true; // CW
        compensation = 0.0;
    }
    
    float compensate(float rawPosition, bool currentDirection) {
        if (currentDirection != lastDirection) {
            // تغییر جهت - اعمال جبران لقی
            compensation = currentDirection ? backlashAngle : -backlashAngle;
            lastDirection = currentDirection;
        }
        
        return rawPosition + compensation;
    }
    
    void calibrate() {
        Serial.println("کالیبراسیون لقی مکانیکی:");
        Serial.println("به آرامی در هر دو جهت حرکت دهید...");
        
        // روش کالیبراسیون
        // ...
    }
};

class EncoderHealthMonitor {
private:
    RotaryEncoder& encoder;
    unsigned long lastPulseTime;
    float expectedMinRPM;
    bool encoderFault;
    
public:
    EncoderHealthMonitor(RotaryEncoder& enc, float minRPM = 10.0)
        : encoder(enc), expectedMinRPM(minRPM) {
        lastPulseTime = 0;
        encoderFault = false;
    }
    
    void monitor() {
        encoder.updateVelocity();
        float currentRPM = encoder.getRPM();
        
        // بررسی سرعت
        if (abs(currentRPM) > 0.1 && abs(currentRPM) < expectedMinRPM) {
            Serial.println("⚠️ سرعت غیرعادی پایین");
        }
        
        // بررسی پالس‌ها
        if (currentRPM == 0.0 && millis() - lastPulseTime > 5000) {
            Serial.println("⚠️ عدم دریافت پالس در 5 ثانیه");
            encoderFault = true;
        }
        
        // به‌روزرسانی زمان آخرین پالس
        if (currentRPM != 0.0) {
            lastPulseTime = millis();
            encoderFault = false;
        }
    }
    
    bool hasFault() {
        return encoderFault;
    }
    
    void runDiagnostics() {
        Serial.println("=== تست تشخیصی انکودر ===");
        
        // تست کانال A
        testChannel(encoder.getPinA(), "کانال A");
        
        // تست کانال B
        testChannel(encoder.getPinB(), "کانال B");
        
        // تست کانال Z
        if (encoder.hasIndex()) {
            testChannel(encoder.getPinZ(), "کانال Z");
        }
        
        // تست تغذیه
        testPowerSupply();
        
        Serial.println("تست تشخیصی کامل شد");
    }
};

enum ApplicationType {
    ROBOTICS,       // نیاز به دقت و سرعت بالا
    CNC_MACHINE,    // نیاز به موقعیت مطلق
    CONVEYOR,       // نیاز به دوام در محیط صنعتی
    LAB_EQUIPMENT,  // نیاز به دقت بسیار بالا
    AUTOMOTIVE,     // نیاز به مقاومت در دماهای شدید
};

RotaryEncoder* selectEncoder(ApplicationType app, int budget, int precision) {
    switch(app) {
        case ROBOTICS:
            return new RotaryEncoder(2, 3, -1, 2000); // 2000 PPR نوری
        case CNC_MACHINE:
            // انکودر مطلق با رابط SSI
            return new AbsoluteEncoder(/* پارامترها */);
        case CONVEYOR:
            return new RotaryEncoder(2, 3, -1, 500); // 500 PPR مغناطیسی
        case LAB_EQUIPMENT:
            return new HighPrecisionEncoder(/* پارامترها */); // 5000 PPR
        case AUTOMOTIVE:
            return new AutomotiveEncoder(/* پارامترها */);
    }
    return nullptr;
}

class CNCController {
private:
    RotaryEncoder xAxis, yAxis, zAxis;
    float xPos, yPos, zPos;
    
public:
    CNCController() : 
        xAxis(2, 3, 4, 2000),
        yAxis(5, 6, 7, 2000),
        zAxis(8, 9, 10, 1000) {
        
        xPos = yPos = zPos = 0.0;
    }
    
    void updatePositions() {
        xAxis.updateVelocity();
        yAxis.updateVelocity();
        zAxis.updateVelocity();
        
        // انتگرال گیری برای موقعیت
        static unsigned long lastUpdate = 0;
        unsigned long now = micros();
        float dt = (now - lastUpdate) / 1000000.0;
        
        xPos += xAxis.getAngularVelocity() * dt * SCREW_PITCH_X;
        yPos += yAxis.getAngularVelocity() * dt * SCREW_PITCH_Y;
        zPos += zAxis.getAngularVelocity() * dt * SCREW_PITCH_Z;
        
        lastUpdate = now;
    }
    
    void moveTo(float x, float y, float z) {
        // کنترل حلقه بسته موقعیت
        // ...
    }
    
    void printStatus() {
        Serial.print("X: ");
        Serial.print(xPos, 3);
        Serial.print("mm Y: ");
        Serial.print(yPos, 3);
        Serial.print("mm Z: ");
        Serial.print(zPos, 3);
        Serial.println("mm");
    }
};

class MotorTestBench {
private:
    RotaryEncoder encoder;
    float torqueConstant;
    float noLoadRPM;
    float stallTorque;
    
public:
    MotorTestBench(int a, int b, int ppr) : encoder(a, b, -1, ppr) {
        torqueConstant = 0.0;
        noLoadRPM = 0.0;
        stallTorque = 0.0;
    }
    
    void characterizeMotor(float voltage) {
        Serial.println("=== مشخصه‌یابی موتور ===");
        
        // تست بدون بار
        testNoLoad(voltage);
        
        // تست با بار
        testWithLoad(voltage);
        
        // تست استال
        testStall(voltage);
        
        // محاسبه ثابت‌ها
        calculateConstants();
        
        printMotorSpecs();
    }
    
    void testNoLoad(float voltage) {
        Serial.println("تست بدون بار...");
        // ...
    }
    
    void calculateEfficiency(float inputPower, float outputPower) {
        float efficiency = (outputPower / inputPower) * 100.0;
        Serial.print("راندمان موتور: ");
        Serial.print(efficiency, 1);
        Serial.println("%");
        
        if (efficiency < 60.0) {
            Serial.println("⚠️ راندمان پایین - موتور نیاز به بررسی دارد");
        }
    }
};