پین 1: VCC (3.3V - 5V)
پین 2: GND
پین 3: DO (Digital Output) - خروجی دیجیتال
پین 4: AO (Analog Output) - خروجی آنالوگ

*DO زمانی HIGH می‌شود که نور از آستانه تنظیم شده کمتر باشد

VCC → LDR → AO → میکروکنترلر (آنالوگ)
       ↓
مقاومت 10KΩ → GND

AO همچنین به مقایسه‌گر LM393 وارد می‌شود
پتانسیومتر آستانه ←→ LM393 ←→ DO

// اتصال ساده LDR به آردوینو
#define LDR_ANALOG_PIN A0    // خروجی آنالوگ
#define LDR_DIGITAL_PIN 2    // خروجی دیجیتال

void setup() {
  Serial.begin(9600);
  pinMode(LDR_DIGITAL_PIN, INPUT);
  
  Serial.println("ماژول LDR راه‌اندازی شد");
  Serial.println("========================");
}

void loop() {
  // خواندن مقدار آنالوگ (0-1023)
  int analogValue = analogRead(LDR_ANALOG_PIN);
  
  // خواندن وضعیت دیجیتال
  bool digitalState = digitalRead(LDR_DIGITAL_PIN);
  
  // تبدیل به ولتاژ
  float voltage = analogValue * (5.0 / 1023.0);
  
  // محاسبه مقاومت LDR
  // با فرض مقاومت سری 10KΩ
  float ldrResistance = 10000.0 * (5.0 / voltage - 1.0);
  
  // نمایش اطلاعات
  Serial.print("آنالوگ: ");
  Serial.print(analogValue);
  Serial.print(" | ولتاژ: ");
  Serial.print(voltage, 2);
  Serial.print("V | مقاومت LDR: ");
  Serial.print(ldrResistance / 1000.0, 1);
  Serial.print("KΩ | دیجیتال: ");
  Serial.println(digitalState ? "HIGH (تاریک)" : "LOW (روشن)");
  
  delay(1000);
}

روش تنظیم:
1. نور محیط را در سطح مورد نظر تنظیم کنید
2. پتانسیومتر را بچرخانید تا LED نشانگر روشن/خاموش شود
3. در این نقطه، آستانه روی همان سطح نور تنظیم شده است
4. وقتی نور از این آستانه کمتر شود، خروجی دیجیتال HIGH می‌شود

class LDRSensor {
  private:
    int analogPin;
    int digitalPin;
    int referenceResistor; // مقاومت سری (معمولاً 10KΩ)
    float vcc; // ولتاژ تغذیه
    
    // کالیبراسیون
    float darkResistance;
    float lightResistance;
    
  public:
    LDRSensor(int aPin, int dPin, int refR = 10000, float voltage = 5.0) {
      analogPin = aPin;
      digitalPin = dPin;
      referenceResistor = refR;
      vcc = voltage;
      
      pinMode(digitalPin, INPUT);
      
      // مقادیر پیش‌فرض کالیبراسیون
      darkResistance = 2000000.0; // 2MΩ در تاریکی
      lightResistance = 10000.0;  // 10KΩ در نور
    }
    
    // خواندن مقدار خام آنالوگ
    int readRaw() {
      return analogRead(analogPin);
    }
    
    // خواندن ولتاژ
    float readVoltage() {
      int raw = readRaw();
      return raw * (vcc / 1023.0);
    }
    
    // محاسبه مقاومت LDR
    float calculateResistance() {
      float voltage = readVoltage();
      
      if(voltage <= 0) return -1; // جلوگیری از تقسیم بر صفر
      
      // فرمول تقسیم ولتاژ: Vout = Vcc * (R2 / (R1 + R2))
      // که R2 = مقاومت LDR
      float ldrResistance = referenceResistor * ((vcc / voltage) - 1.0);
      
      return ldrResistance;
    }
    
    // تخمین شدت نور (لوکس) - تقریبی
    float estimateLux() {
      float resistance = calculateResistance();
      
      if(resistance <= 0) return 0;
      
      // تقریب خطی در مقیاس لگاریتمی
      // مقاومت LDR معمولاً با لوکس رابطه معکوس لگاریتمی دارد
      float logResistance = log10(resistance);
      float logDark = log10(darkResistance);
      float logLight = log10(lightResistance);
      
      // مقیاس‌بندی بین 0.1 لوکس (تاریک) تا 1000 لوکس (روشن)
      float lux = pow(10, 
        ((logResistance - logDark) / (logLight - logDark)) * 3 + (-1)
      );
      
      return lux;
    }
    
    // خواندن وضعیت دیجیتال
    bool isDark() {
      return digitalRead(digitalPin) == HIGH;
    }
    
    // خواندن وضعیت دیجیتال معکوس (برای نور زیاد)
    bool isBright() {
      return !isDark();
    }
    
    // کالیبراسیون دستی
    void calibrateDark() {
      Serial.println("کالیبراسیون تاریکی: سنسور را در تاریکی کامل قرار دهید");
      delay(5000);
      darkResistance = calculateResistance();
      Serial.print("مقاومت تاریکی ثبت شد: ");
      Serial.print(darkResistance / 1000.0);
      Serial.println("KΩ");
    }
    
    void calibrateLight() {
      Serial.println("کالیبراسیون نور: سنسور را در نور مناسب قرار دهید");
      delay(5000);
      lightResistance = calculateResistance();
      Serial.print("مقاومت نور ثبت شد: ");
      Serial.print(lightResistance / 1000.0);
      Serial.println("KΩ");
    }
    
    // نمایش اطلاعات کامل
    void printInfo() {
      int raw = readRaw();
      float voltage = readVoltage();
      float resistance = calculateResistance();
      float lux = estimateLux();
      
      Serial.println("=== اطلاعات سنسور LDR ===");
      Serial.print("مقدار خام ADC: ");
      Serial.println(raw);
      
      Serial.print("ولتاژ: ");
      Serial.print(voltage, 3);
      Serial.println(" V");
      
      Serial.print("مقاومت LDR: ");
      if(resistance >= 1000000) {
        Serial.print(resistance / 1000000.0, 2);
        Serial.println(" MΩ");
      } else if(resistance >= 1000) {
        Serial.print(resistance / 1000.0, 1);
        Serial.println(" KΩ");
      } else {
        Serial.print(resistance, 0);
        Serial.println(" Ω");
      }
      
      Serial.print("شدت نور تخمینی: ");
      Serial.print(lux, 1);
      Serial.println(" لوکس");
      
      Serial.print("وضعیت دیجیتال: ");
      Serial.println(isDark() ? "تاریک (HIGH)" : "روشن (LOW)");
      
      Serial.println("========================");
    }
};

// استفاده از کلاس
LDRSensor ldr(A0, 2); // آنالوگ: A0, دیجیتال: D2

void setup() {
  Serial.begin(9600);
  
  // کالیبراسیون (اختیاری)
  // ldr.calibrateDark();
  // ldr.calibrateLight();
  
  Serial.println("سنسور LDR با کلاس مدیریت راه‌اندازی شد");
}

void loop() {
  ldr.printInfo();
  
  // کنترل بر اساس شرایط نوری
  if(ldr.isDark()) {
    Serial.println("هشدار: محیط تاریک است!");
    // می‌توانید چراغ‌ها را روشن کنید
  }
  
  float lux = ldr.estimateLux();
  if(lux > 500) {
    Serial.println("نور بسیار زیاد! ممکن است به سنسور آسیب برسد");
  }
  
  delay(2000);
}

class AutomaticLightControl {
  private:
    LDRSensor* ldr;
    int lightPin; // پین کنترل چراغ (رله یا LED)
    float onThreshold; // آستانه روشن شدن (لوکس)
    float offThreshold; // آستانه خاموش شدن (لوکس)
    bool hysteresisEnabled;
    
  public:
    AutomaticLightControl(LDRSensor* sensor, int pin, 
                         float onLux = 50, float offLux = 100) {
      ldr = sensor;
      lightPin = pin;
      onThreshold = onLux;
      offThreshold = offLux;
      hysteresisEnabled = true;
      
      pinMode(lightPin, OUTPUT);
      digitalWrite(lightPin, LOW);
    }
    
    void update() {
      float currentLux = ldr->estimateLux();
      bool lightState = digitalRead(lightPin);
      
      if(hysteresisEnabled) {
        // هیسترزیس برای جلوگیری از نوسان
        if(!lightState && currentLux <= onThreshold) {
          turnOnLight();
        } else if(lightState && currentLux >= offThreshold) {
          turnOffLight();
        }
      } else {
        // بدون هیسترزیس
        if(currentLux <= onThreshold) {
          turnOnLight();
        } else {
          turnOffLight();
        }
      }
    }
    
    void turnOnLight() {
      digitalWrite(lightPin, HIGH);
      Serial.println("چراغ روشن شد (نور کم)");
    }
    
    void turnOffLight() {
      digitalWrite(lightPin, LOW);
      Serial.println("چراغ خاموش شد (نور کافی)");
    }
    
    void setThresholds(float onLux, float offLux) {
      onThreshold = onLux;
      offThreshold = offLux;
      Serial.print("آستانه‌ها تنظیم شد: روشن = ");
      Serial.print(onLux);
      Serial.print(" لوکس، خاموش = ");
      Serial.print(offLux);
      Serial.println(" لوکس");
    }
    
    void enableHysteresis(bool enable) {
      hysteresisEnabled = enable;
      Serial.print("هیسترزیس ");
      Serial.println(enable ? "فعال شد" : "غیرفعال شد");
    }
};

// استفاده
LDRSensor myLDR(A0, 2);
AutomaticLightControl lightControl(&myLDR, 8, 50, 100); // چراغ روی پین 8

void setup() {
  Serial.begin(9600);
  Serial.println("سیستم کنترل نور اتوماتیک راه‌اندازی شد");
}

void loop() {
  lightControl.update();
  
  // نمایش وضعیت هر 5 ثانیه
  static unsigned long lastPrint = 0;
  if(millis() - lastPrint > 5000) {
    lastPrint = millis();
    myLDR.printInfo();
  }
  
  delay(100);
}

#include <SD.h>
#include <SPI.h>

class LightDataLogger {
  private:
    LDRSensor* ldr;
    File dataFile;
    unsigned long logInterval;
    unsigned long lastLogTime;
    bool loggingEnabled;
    
  public:
    LightDataLogger(LDRSensor* sensor, unsigned long interval = 60000) {
      ldr = sensor;
      logInterval = interval; // هر 1 دقیقه پیش‌فرض
      lastLogTime = 0;
      loggingEnabled = false;
    }
    
    bool begin() {
      if(!SD.begin(4)) { // پین CS معمولاً 4
        Serial.println("خطا در راه‌اندازی کارت SD!");
        return false;
      }
      
      // باز کردن فایل برای نوشتن
      dataFile = SD.open("light_log.csv", FILE_WRITE);
      if(!dataFile) {
        Serial.println("خطا در ایجاد فایل!");
        return false;
      }
      
      // نوشتن هدر CSV
      dataFile.println("Time(ms),RawADC,Voltage(V),Resistance(Ohm),Lux,Digital");
      dataFile.close();
      
      loggingEnabled = true;
      Serial.println("دیتالاگر نور راه‌اندازی شد");
      return true;
    }
    
    void update() {
      if(!loggingEnabled) return;
      
      unsigned long currentTime = millis();
      if(currentTime - lastLogTime >= logInterval) {
        lastLogTime = currentTime;
        logData();
      }
    }
    
    void logData() {
      dataFile = SD.open("light_log.csv", FILE_WRITE);
      if(dataFile) {
        int raw = ldr->readRaw();
        float voltage = ldr->readVoltage();
        float resistance = ldr->calculateResistance();
        float lux = ldr->estimateLux();
        bool digital = ldr->isDark();
        
        dataFile.print(millis());
        dataFile.print(",");
        dataFile.print(raw);
        dataFile.print(",");
        dataFile.print(voltage, 3);
        dataFile.print(",");
        dataFile.print(resistance, 0);
        dataFile.print(",");
        dataFile.print(lux, 2);
        dataFile.print(",");
        dataFile.println(digital ? "DARK" : "LIGHT");
        
        dataFile.close();
        
        Serial.print("داده ثبت شد: ");
        Serial.print(lux, 1);
        Serial.println(" لوکس");
      }
    }
    
    void setLogInterval(unsigned long interval) {
      logInterval = interval;
      Serial.print("فاصله ثبت داده به ");
      Serial.print(interval / 1000);
      Serial.println(" ثانیه تنظیم شد");
    }
    
    void stop() {
      loggingEnabled = false;
      Serial.println("ثبت داده متوقف شد");
    }
};

// استفاده
LDRSensor ldrSensor(A0, 2);
LightDataLogger dataLogger(&ldrSensor, 30000); // هر 30 ثانیه

void setup() {
  Serial.begin(9600);
  
  if(dataLogger.begin()) {
    Serial.println("دیتالاگر آماده است");
  }
}

void loop() {
  dataLogger.update();
  delay(1000);
}

1. مقاومت LDR از ولتاژ:
   R_ldr = R_series * (Vcc / V_out - 1)

2. ولتاژ خروجی:
   V_out = Vcc * (R_series / (R_ldr + R_series))

3. تخمین لوکس (رابطه تجربی):
   لوکس ≈ 10^((log(R_ldr) - log(R_dark)) / (log(R_light) - log(R_dark)) * 3 - 1)

// استفاده از 4 LDR برای ردیابی خورشید
class SunTracker {
  private:
    int ldrPins[4]; // شمال، شرق، جنوب، غرب
    int servoPin;
    
  public:
    SunTracker(int pins[4], int servo) {
      for(int i=0; i<4; i++) {
        ldrPins[i] = pins[i];
      }
      servoPin = servo;
    }
    
    int calculateSunPosition() {
      int values[4];
      for(int i=0; i<4; i++) {
        values[i] = analogRead(ldrPins[i]);
      }
      
      // محاسبه جهت بیشترین نور
      int maxIndex = 0;
      int maxValue = values[0];
      
      for(int i=1; i<4; i++) {
        if(values[i] > maxValue) {
          maxValue = values[i];
          maxIndex = i;
        }
      }
      
      return maxIndex; // 0: شمال، 1: شرق، 2: جنوب، 3: غرب
    }
};

// برای امنیت پنجره‌ها و ویترین‌ها
class LightBreakDetector {
  private:
    LDRSensor* ldr;
    float baselineLux;
    float thresholdPercent;
    bool alarmActive;
    
  public:
    LightBreakDetector(LDRSensor* sensor, float threshold = 30.0) {
      ldr = sensor;
      thresholdPercent = threshold;
      alarmActive = false;
      
      // ثبت نور پایه
      delay(1000);
      baselineLux = ldr->estimateLux();
      Serial.print("نور پایه ثبت شد: ");
      Serial.print(baselineLux, 1);
      Serial.println(" لوکس");
    }
    
    void check() {
      float currentLux = ldr->estimateLux();
      float changePercent = abs(currentLux - baselineLux) / baselineLux * 100;
      
      if(changePercent > thresholdPercent) {
        if(!alarmActive) {
          triggerAlarm();
          alarmActive = true;
        }
      } else {
        alarmActive = false;
      }
    }
    
    void triggerAlarm() {
      Serial.println("هشدار: تغییر ناگهانی نور تشخیص داده شد!");
      // فعال کردن آلارم صوتی/نوری
    }
};

// روش نمونه‌برداری کم‌مصرف
void lowPowerMeasurement() {
  // روشن کردن ماژول
  digitalWrite(LDR_POWER_PIN, HIGH);
  delay(10); // منتظر تثبیت
  
  // خواندن مقدار
  int value = analogRead(LDR_PIN);
  
  // خاموش کردن ماژول
  digitalWrite(LDR_POWER_PIN, LOW);
  
  return value;
}