فرستنده IR      گیرنده IR
         |               |
    [====|===============|====]  ← جسم
         |               |
      نور IR ------>   دریافت نور
     
• هنگامی که جسمی در شکاف قرار نمی‌گیرد: گیرنده نور را دریافت می‌کند → خروجی LOW
• هنگامی که جسمی شکاف را می‌بندد: نور قطع می‌شود → خروجی HIGH

ماژول شکست نوری ← آردوینو
-------------------------
VCC  → 5V
GND  → GND
OUT  → پایه دیجیتال (مثلاً D2)

/*
 * تشخیص قطع و وصل پرتو نور با ماژول شکست نوری
 * اتصال: پایه OUT ماژول به D2
 */

const int sensorPin = 2;        // پایه اتصال سنسور
const int ledPin = 13;          // LED داخلی آردوینو
const int buzzerPin = 8;        // بوق هشدار (اختیاری)

int sensorState = LOW;          // وضعیت فعلی سنسور
int lastState = LOW;            // وضعیت قبلی
unsigned long objectCount = 0;  // شمارش اشیاء
unsigned long lastBreakTime = 0; // زمان آخرین قطعی
unsigned long totalBlockTime = 0; // مجموع زمان مسدود بودن

void setup() {
  Serial.begin(9600);
  pinMode(sensorPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  
  Serial.println("=========================================");
  Serial.println("   Optical Break Beam Sensor Test");
  Serial.println("=========================================");
  Serial.println("Status    | Count | Block Time | Total");
  Serial.println("----------|-------|------------|------");
}

void loop() {
  sensorState = digitalRead(sensorPin);
  
  // تشخیص شروع مسدود شدن (لبه بالارونده)
  if (sensorState == HIGH && lastState == LOW) {
    objectCount++;
    lastBreakTime = millis();
    
    digitalWrite(ledPin, HIGH);
    tone(buzzerPin, 1000, 50);
    
    Serial.print("BLOCKED   | ");
    Serial.print(objectCount);
    Serial.print("    | ");
    Serial.print(millis() / 1000.0, 1);
    Serial.print("s     | ");
    Serial.print(totalBlockTime / 1000.0, 1);
    Serial.println("s");
  }
  
  // تشخیص پایان مسدود شدن (لبه پایین‌رونده)
  if (sensorState == LOW && lastState == HIGH) {
    unsigned long blockDuration = millis() - lastBreakTime;
    totalBlockTime += blockDuration;
    
    digitalWrite(ledPin, LOW);
    
    Serial.print("CLEAR     | ");
    Serial.print(objectCount);
    Serial.print("    | ");
    Serial.print(blockDuration);
    Serial.print("ms    | ");
    Serial.print(totalBlockTime / 1000.0, 1);
    Serial.println("s");
  }
  
  lastState = sensorState;
  
  // نمایش دوره‌ای وضعیت
  static unsigned long lastDisplay = 0;
  if (millis() - lastDisplay > 5000) {
    Serial.println("----------|-------|------------|------");
    Serial.print("SUMMARY   | Total: ");
    Serial.print(objectCount);
    Serial.print(" | Avg Time: ");
    if (objectCount > 0) {
      Serial.print(totalBlockTime / objectCount);
      Serial.print("ms");
    } else {
      Serial.print("N/A");
    }
    Serial.print(" | Rate: ");
    Serial.print(objectCount / ((millis() / 1000.0) + 1), 1);
    Serial.println(" objects/sec");
    Serial.println("=========================================");
    lastDisplay = millis();
  }
  
  delay(1); // تأخیر بسیار کوتاه برای پاسخ سریع
}

/*
 * شمارنده سرعت بالا با استفاده از وقفه
 * مناسب برای شمارش پره‌های فن یا چرخ‌دنده‌ها
 */

const int sensorPin = 2;        // باید پایه وقفه باشد (در Uno: D2 یا D3)
const int ledPin = 13;

volatile unsigned long pulseCount = 0; // volatile برای وقفه
unsigned long lastCount = 0;
unsigned long lastTime = 0;
float rpm = 0.0;
float frequency = 0.0;

// پیکربندی
const int SLOTS_PER_REVOLUTION = 20; // تعداد شکاف در چرخ‌دنده
const unsigned long DEBOUNCE_DELAY = 100; // میکروثانیه

void setup() {
  Serial.begin(115200);
  pinMode(ledPin, OUTPUT);
  
  // تنظیم وقفه روی لبه بالارونده (قطع پرتو)
  attachInterrupt(digitalPinToInterrupt(sensorPin), pulseCounter, RISING);
  
  Serial.println("=========================================");
  Serial.println("   High-Speed Optical Tachometer");
  Serial.println("=========================================");
  Serial.println("RPM     | Frequency | Count | Rate");
  Serial.println("--------|-----------|-------|------");
  
  lastTime = millis();
}

void loop() {
  unsigned long currentTime = millis();
  unsigned long elapsedTime = currentTime - lastTime;
  
  // هر 500ms محاسبات را انجام بده
  if (elapsedTime >= 500) {
    // غیرفعال کردن وقفه هنگام خواندن متغیر مشترک
    noInterrupts();
    unsigned long currentCount = pulseCount;
    interrupts();
    
    unsigned long pulses = currentCount - lastCount;
    
    // محاسبات
    frequency = (pulses * 1000.0) / elapsedTime; // هرتز
    rpm = (frequency * 60.0) / SLOTS_PER_REVOLUTION;
    
    // نمایش نتایج
    Serial.print(rpm, 0);
    Serial.print("    | ");
    Serial.print(frequency, 1);
    Serial.print("Hz   | ");
    Serial.print(currentCount);
    Serial.print("   | ");
    Serial.print(pulses * 2); // ×2 چون هر 500ms است
    Serial.println(" pulses/sec");
    
    // چشمک زدن LED متناسب با سرعت
    if (rpm > 0) {
      int blinkDelay = constrain(1000 / (rpm / 60.0), 50, 500);
      digitalWrite(ledPin, HIGH);
      delay(10);
      digitalWrite(ledPin, LOW);
    }
    
    lastCount = currentCount;
    lastTime = currentTime;
  }
  
  // تنظیم مجدد شمارنده هر 60 ثانیه
  if (currentTime > 60000) {
    noInterrupts();
    pulseCount = 0;
    interrupts();
    lastCount = 0;
    lastTime = millis();
    Serial.println("----- Counter Reset -----");
  }
}

// تابع وقفه - باید کوتاه و سریع باشد
void pulseCounter() {
  static unsigned long lastInterruptTime = 0;
  unsigned long interruptTime = micros();
  
  // Debouncing سخت‌افزاری/نرم‌افزاری
  if (interruptTime - lastInterruptTime > DEBOUNCE_DELAY) {
    pulseCount++;
  }
  lastInterruptTime = interruptTime;
}

/*
 * سیستم امنیتی با چندین ماژول شکست نوری
 * تشخیص نفوذ از پنجره‌ها، درها و ...
 */

const int numSensors = 4; // تعداد سنسورها
const int sensorPins[] = {2, 3, 4, 5}; // پایه‌های سنسور
const int zoneLEDs[] = {8, 9, 10, 11}; // LED‌های نمایش وضعیت زون
const int alarmLED = 12;               // LED هشدار اصلی
const int alarmBuzzer = 13;            // بوق هشدار
const int resetButton = 6;             // دکمه ریست
const int armButton = 7;               // دکمه فعال‌سازی سیستم

// وضعیت زون‌ها
bool zoneStatus[numSensors] = {false, false, false, false};
bool zoneTripped[numSensors] = {false, false, false, false};
bool systemArmed = false;
bool alarmActive = false;
unsigned long alarmStartTime = 0;
const unsigned long ALARM_DURATION = 300000; // 5 دقیقه

// تایمر برای ضدحملات
unsigned long lastTripTime[numSensors];
const unsigned long DEBOUNCE_TIME = 200; // ms

void setup() {
  Serial.begin(9600);
  
  // تنظیم پایه‌ها
  for (int i = 0; i < numSensors; i++) {
    pinMode(sensorPins[i], INPUT);
    pinMode(zoneLEDs[i], OUTPUT);
    digitalWrite(zoneLEDs[i], LOW);
    lastTripTime[i] = 0;
  }
  
  pinMode(alarmLED, OUTPUT);
  pinMode(alarmBuzzer, OUTPUT);
  pinMode(resetButton, INPUT_PULLUP);
  pinMode(armButton, INPUT_PULLUP);
  
  Serial.println("=========================================");
  Serial.println("   Multi-Zone Security System");
  Serial.println("=========================================");
  Serial.println("Commands: A=Arm, D=Disarm, S=Status");
  Serial.println("Zones: 1=Window, 2=Door, 3=Garage, 4=Hall");
  Serial.println("-----------------------------------------");
}

void loop() {
  // خواندن دکمه‌ها
  checkButtons();
  
  // خواندن سنسورها اگر سیستم Armed است
  if (systemArmed && !alarmActive) {
    readSensors();
  }
  
  // کنترل هشدار
  if (alarmActive) {
    activateAlarm();
  }
  
  // نمایش وضعیت
  static unsigned long lastDisplay = 0;
  if (millis() - lastDisplay > 2000) {
    displayStatus();
    lastDisplay = millis();
  }
  
  delay(50);
}

void checkButtons() {
  // دکمه فعال‌سازی
  if (digitalRead(armButton) == LOW) {
    delay(300); // Debouncing
    systemArmed = !systemArmed;
    
    if (systemArmed) {
      Serial.println("System ARMED");
      // بوق کوتاه تأیید
      tone(alarmBuzzer, 1500, 100);
      delay(200);
      tone(alarmBuzzer, 2000, 100);
      
      // چک کردن سالم بودن همه سنسورها
      bool allClear = true;
      for (int i = 0; i < numSensors; i++) {
        if (digitalRead(sensorPins[i]) == HIGH) {
          Serial.print("WARNING: Zone ");
          Serial.print(i + 1);
          Serial.println(" is blocked!");
          allClear = false;
        }
      }
      
      if (!allClear) {
        Serial.println("Cannot arm system - zones blocked");
        systemArmed = false;
        tone(alarmBuzzer, 300, 500);
      }
    } else {
      Serial.println("System DISARMED");
      tone(alarmBuzzer, 1000, 100);
      // خاموش کردن هشدار اگر فعال است
      alarmActive = false;
      digitalWrite(alarmLED, LOW);
      noTone(alarmBuzzer);
    }
  }
  
  // دکمه ریست هشدار
  if (digitalRead(resetButton) == LOW && alarmActive) {
    delay(300);
    alarmActive = false;
    digitalWrite(alarmLED, LOW);
    noTone(alarmBuzzer);
    Serial.println("Alarm reset by user");
  }
}

void readSensors() {
  for (int i = 0; i < numSensors; i++) {
    int sensorState = digitalRead(sensorPins[i]);
    
    // اگر پرتو قطع شد (HIGH) و قبلاً در حالت clear بود
    if (sensorState == HIGH && !zoneTripped[i]) {
      // Debouncing
      if (millis() - lastTripTime[i] > DEBOUNCE_TIME) {
        zoneTripped[i] = true;
        lastTripTime[i] = millis();
        
        Serial.print("INTRUSION DETECTED! Zone ");
        Serial.println(i + 1);
        Serial.print("Time: ");
        Serial.println(millis() / 1000.0, 1);
        
        // فعال‌سازی هشدار
        triggerAlarm(i);
      }
    }
    
    // اگر پرتو وصل شد (LOW) و قبلاً tripped بود
    if (sensorState == LOW && zoneTripped[i]) {
      zoneTripped[i] = false;
      Serial.print("Zone ");
      Serial.print(i + 1);
      Serial.println(" clear again");
    }
    
    // به‌روزرسانی LED زون
    digitalWrite(zoneLEDs[i], zoneTripped[i] ? HIGH : LOW);
  }
}

void triggerAlarm(int zone) {
  alarmActive = true;
  alarmStartTime = millis();
  
  Serial.println("!!! ALARM ACTIVATED !!!");
  Serial.print("Breach in Zone ");
  Serial.println(zone + 1);
  Serial.println("-----------------------------------------");
  
  // روشن کردن LED هشدار
  digitalWrite(alarmLED, HIGH);
}

void activateAlarm() {
  // بوق هشدار الگویی
  static unsigned long lastBeep = 0;
  static bool beepState = false;
  
  if (millis() - lastBeep > (beepState ? 100 : 900)) {
    beepState = !beepState;
    if (beepState) {
      tone(alarmBuzzer, 1200, 100);
    } else {
      noTone(alarmBuzzer);
    }
    lastBeep = millis();
  }
  
  // چشمک‌زدن LED
  digitalWrite(alarmLED, (millis() / 200) % 2 == 0);
  
  // پایان خودکار هشدار پس از مدت معین
  if (millis() - alarmStartTime > ALARM_DURATION) {
    alarmActive = false;
    digitalWrite(alarmLED, LOW);
    noTone(alarmBuzzer);
    Serial.println("Alarm auto-disarmed after 5 minutes");
  }
}

void displayStatus() {
  Serial.print("Status: ");
  Serial.print(systemArmed ? "ARMED" : "DISARMED");
  Serial.print(" | Alarm: ");
  Serial.print(alarmActive ? "ACTIVE" : "INACTIVE");
  Serial.print(" | Zones: ");
  
  for (int i = 0; i < numSensors; i++) {
    Serial.print(digitalRead(sensorPins[i]) == HIGH ? "B" : "C");
    if (i < numSensors - 1) Serial.print(",");
  }
  
  Serial.println();
}

// کنترل از طریق سریال مانیتور
void serialEvent() {
  while (Serial.available()) {
    char command = Serial.read();
    
    switch (command) {
      case 'A':
      case 'a':
        systemArmed = true;
        Serial.println("System armed via serial");
        break;
        
      case 'D':
      case 'd':
        systemArmed = false;
        alarmActive = false;
        Serial.println("System disarmed via serial");
        break;
        
      case 'S':
      case 's':
        displayDetailedStatus();
        break;
        
      case 'R':
      case 'r':
        // تست هر زون
        for (int i = 0; i < numSensors; i++) {
          Serial.print("Zone ");
          Serial.print(i + 1);
          Serial.print(": ");
          Serial.println(digitalRead(sensorPins[i]) == HIGH ? "BLOCKED" : "CLEAR");
        }
        break;
    }
  }
}

void displayDetailedStatus() {
  Serial.println();
  Serial.println("=== SYSTEM STATUS ===");
  Serial.print("Uptime: ");
  Serial.print(millis() / 1000.0 / 60.0, 1);
  Serial.println(" minutes");
  
  Serial.println("\nZone Status:");
  Serial.println("No | Sensor | Tripped | Description");
  Serial.println("---|--------|---------|------------");
  
  String zoneNames[] = {"Window", "Door", "Garage", "Hall"};
  
  for (int i = 0; i < numSensors; i++) {
    Serial.print(i + 1);
    Serial.print("  | ");
    Serial.print(digitalRead(sensorPins[i]) == HIGH ? "BLOCKED " : "CLEAR   ");
    Serial.print(" | ");
    Serial.print(zoneTripped[i] ? "YES     " : "NO      ");
    Serial.print(" | ");
    Serial.println(zoneNames[i]);
  }
  
  Serial.println("=====================");
  Serial.println();
}

/*
 * انکودر نوری با دو کانال برای تشخیص جهت
 * نیاز به دو ماژول شکست نوری با فاصله مناسب
 */

const int CHANNEL_A = 2; // کانال A (پایه وقفه)
const int CHANNEL_B = 3; // کانال B (پایه وقفه)

volatile long encoderCount = 0;
volatile long lastEncoderCount = 0;
int lastA = LOW;
int lastB = LOW;
float position = 0.0; // موقعیت بر حسب واحد دلخواه
float velocity = 0.0; // سرعت

// پیکربندی انکودر
const int PULSES_PER_REVOLUTION = 400; // پالس در هر دور
const float DISTANCE_PER_PULSE = 0.1; // میلی‌متر در هر پالس
const unsigned long VELOCITY_INTERVAL = 100; // ms برای محاسبه سرعت

unsigned long lastVelocityTime = 0;
long lastCountForVelocity = 0;

void setup() {
  Serial.begin(115200);
  
  pinMode(CHANNEL_A, INPUT_PULLUP);
  pinMode(CHANNEL_B, INPUT_PULLUP);
  
  // تنظیم وقفه‌ها برای هر دو کانال
  attachInterrupt(digitalPinToInterrupt(CHANNEL_A), handleEncoder, CHANGE);
  attachInterrupt(digitalPinToInterrupt(CHANNEL_B), handleEncoder, CHANGE);
  
  Serial.println("=========================================");
  Serial.println("   Optical Encoder - Position & Velocity");
  Serial.println("=========================================");
  Serial.println("Position (mm) | Velocity (mm/s) | RPM");
  Serial.println("--------------|-----------------|-----");
}

void loop() {
  // محاسبه موقعیت
  position = encoderCount * DISTANCE_PER_PULSE;
  
  // محاسبه سرعت
  unsigned long currentTime = millis();
  if (currentTime - lastVelocityTime >= VELOCITY_INTERVAL) {
    long deltaCount = encoderCount - lastCountForVelocity;
    float deltaTime = (currentTime - lastVelocityTime) / 1000.0; // ثانیه
    
    if (deltaTime > 0) {
      velocity = (deltaCount * DISTANCE_PER_PULSE) / deltaTime; // mm/s
      
      // محاسبه RPM
      float rpm = (abs(velocity) * 60.0) / (PI * 2.0 * 10.0); // فرض قطر 20mm
      
      Serial.print(position, 1);
      Serial.print("        | ");
      Serial.print(velocity, 1);
      Serial.print("         | ");
      Serial.println(rpm, 0);
    }
    
    lastCountForVelocity = encoderCount;
    lastVelocityTime = currentTime;
  }
  
  // کنترل نمایش بر اساس سرعت
  int displayDelay = map(abs(velocity), 0, 1000, 500, 50);
  delay(displayDelay);
  
  // ریست موقعیت با دکمه (اختیاری)
  if (Serial.available()) {
    char c = Serial.read();
    if (c == 'r' || c == 'R') {
      encoderCount = 0;
      Serial.println("Position reset to zero");
    }
  }
}

void handleEncoder() {
  int a = digitalRead(CHANNEL_A);
  int b = digitalRead(CHANNEL_B);
  
  // تشخیص جهت بر اساس تغییرات
  if (a != lastA) {
    // کانال A تغییر کرده
    if (a == HIGH) {
      if (b == LOW) {
        encoderCount++; // حرکت در جهت مثبت
      } else {
        encoderCount--; // حرکت در جهت منفی
      }
    } else {
      if (b == HIGH) {
        encoderCount++; // حرکت در جهت مثبت
      } else {
        encoderCount--; // حرکت در جهت منفی
      }
    }
  } 
  else if (b != lastB) {
    // کانال B تغییر کرده
    if (b == HIGH) {
      if (a == HIGH) {
        encoderCount++; // حرکت در جهت مثبت
      } else {
        encoderCount--; // حرکت در جهت منفی
      }
    } else {
      if (a == LOW) {
        encoderCount++; // حرکت در جهت مثبت
      } else {
        encoderCount--; // حرکت در جهت منفی
      }
    }
  }
  
  lastA = a;
  lastB = b;
}

// کد فیلتر نویز برای محیط‌های پر نور
bool readFilteredSensor(int pin, int samples = 5, int threshold = 3) {
  int highCount = 0;
  
  for (int i = 0; i < samples; i++) {
    if (digitalRead(pin) == HIGH) {
      highCount++;
    }
    delayMicroseconds(100);
  }
  
  // اگر بیشتر از threshold نمونه HIGH بودند، واقعاً قطع شده
  return (highCount >= threshold);
}

// تنظیم آستانه برای مواد شفاف یا نیمه‌شفاف
void calibrateForMaterial() {
  Serial.println("Calibration: Clear the sensor and press any key");
  while (!Serial.available());
  Serial.read();
  
  int clearReading = 0;
  for (int i = 0; i < 100; i++) {
    clearReading += digitalRead(sensorPin);
    delay(10);
  }
  clearReading /= 100;
  
  Serial.println("Now place material and press any key");
  while (!Serial.available());
  Serial.read();
  
  int materialReading = 0;
  for (int i = 0; i < 100; i++) {
    materialReading += digitalRead(sensorPin);
    delay(10);
  }
  materialReading /= 100;
  
  Serial.print("Clear level: ");
  Serial.print(clearReading);
  Serial.print(" | Material level: ");
  Serial.println(materialReading);
  
  // ذخیره تفاوت برای استفاده در تشخیص
  EEPROM.write(0, materialReading - clearReading);
}

// با صفحه نمایش LCD و قابلیت تنظیم batch size

// اندازه‌گیری سرعت، مسافت و کالری مصرفی

// تشخیص سطح در چندین نقطه از مخزن

// موقعیت‌یابی دقیق بدون تماس فیزیکی

// اندازه‌گیری زمان واکنش افراد