رید سوییچ پایه 1 ---> مقاومت 10kΩ ---> آردوینو 5V
رید سوییچ پایه 2 ---> آردوینو D2
رید سوییچ پایه 2 ---> مقاومت 10kΩ ---> آردوینو GND

// رید سوییچ ساده - تشخیص حضور آهنربا
const int reedPin = 2; // پین متصل به رید سوییچ
int reedState = HIGH; // حالت فعلی (با Pull-up، HIGH یعنی باز)
int lastReedState = HIGH; // حالت قبلی
unsigned long lastDebounceTime = 0;
const unsigned long debounceDelay = 50; // تایم دبانس
int magnetCount = 0; // شمارش تعداد فعال‌سازی

void setup() {
  pinMode(reedPin, INPUT_PULLUP); // فعال کردن مقاومت Pull-up داخلی
  Serial.begin(9600);
  Serial.println("سیستم رید سوییچ بزرگ - راه‌اندازی شد");
  Serial.println("آهنربا را به سنسور نزدیک کنید...");
  Serial.println("==================================");
}

void loop() {
  // خواندن وضعیت سنسور
  int reading = digitalRead(reedPin);
  
  // بررسی تغییر وضعیت
  if (reading != lastReedState) {
    lastDebounceTime = millis(); // ریست تایمر دبانس
  }
  
  // اگر بعد از زمان دبانس وضعیت ثابت ماند
  if ((millis() - lastDebounceTime) > debounceDelay) {
    // اگر وضعیت تغییر کرده
    if (reading != reedState) {
      reedState = reading;
      
      // نمایش وضعیت جدید
      if (reedState == LOW) { // LOW یعنی رید بسته (آهنربا نزدیک)
        magnetCount++;
        Serial.println(">>> آهنربا تشخیص داده شد!");
        Serial.print("تعداد کل تشخیص: ");
        Serial.println(magnetCount);
        Serial.print("زمان: ");
        Serial.print(millis() / 1000);
        Serial.println(" ثانیه");
        Serial.println("----------------------------------");
      } else { // HIGH یعنی رید باز (آهنربا دور)
        Serial.println(">>> آهنربا دور شد");
        Serial.print("مدت اتصال: ");
        Serial.print(millis() - lastDebounceTime - debounceDelay);
        Serial.println(" میلی‌ثانیه");
        Serial.println("----------------------------------");
      }
    }
  }
  
  lastReedState = reading; // ذخیره وضعیت برای چرخه بعد
  
  // نمایش وضعیت لحظه‌ای هر 5 ثانیه
  static unsigned long lastStatusTime = 0;
  if (millis() - lastStatusTime > 5000) {
    Serial.print("وضعیت: ");
    Serial.print(reedState == LOW ? "آهنربا حاضر" : "بدون آهنربا");
    Serial.print(" | شمارش: ");
    Serial.println(magnetCount);
    lastStatusTime = millis();
  }
  
  delay(10); // تاخیر کوتاه برای پایداری
}

ماژول VCC ---> آردوینو 5V
ماژول GND ---> آردوینو GND
ماژول DO ---> آردوینو D3

// رید سوییچ با ماژول پیشرفته
const int reedDigitalPin = 3; // پین دیجیتال
const int reedAnalogPin = A0; // پین آنالوگ (اگر موجود باشد)
const int ledPin = 13; // LED داخلی آردوینو
const int buzzerPin = 8; // پین بازر

int sensitivity = 500; // آستانه حساسیت (برای آنالوگ)
bool alarmEnabled = true; // فعال بودن آلارم
unsigned long lastTriggerTime = 0;
const unsigned long alarmTimeout = 30000; // 30 ثانیه

void setup() {
  pinMode(reedDigitalPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  
  Serial.begin(9600);
  Serial.println("ماژول رید سوییچ بزرگ - سیستم پیشرفته");
  Serial.println("======================================");
  Serial.println("دستورات سریال:");
  Serial.println("S### : تنظیم حساسیت (مثال: S300)");
  Serial.println("A0   : غیرفعال کردن آلارم");
  Serial.println("A1   : فعال کردن آلارم");
  Serial.println("======================================");
}

void loop() {
  // خواندن وضعیت دیجیتال
  int digitalState = digitalRead(reedDigitalPin);
  
  // خواندن مقدار آنالوگ (اگر سنسور آنالوگ دارد)
  int analogValue = 0;
  #ifdef reedAnalogPin
    analogValue = analogRead(reedAnalogPin);
  #endif
  
  // پردازش دستورات سریال
  if (Serial.available() > 0) {
    processSerialCommand();
  }
  
  // اگر آهنربا تشخیص داده شد
  if (digitalState == LOW) {
    handleMagnetDetected(analogValue);
  } else {
    digitalWrite(ledPin, LOW);
    noTone(buzzerPin);
  }
  
  // نمایش اطلاعات هر 2 ثانیه
  static unsigned long lastDisplayTime = 0;
  if (millis() - lastDisplayTime > 2000) {
    displayStatus(digitalState, analogValue);
    lastDisplayTime = millis();
  }
  
  delay(100);
}

void handleMagnetDetected(int analogVal) {
  digitalWrite(ledPin, HIGH);
  
  // اگر آلارم فعال است و مدت زیادی از آخرین آلارم گذشته
  if (alarmEnabled && (millis() - lastTriggerTime > alarmTimeout)) {
    tone(buzzerPin, 2000, 1000);
    Serial.println("!!! هشدار: آهنربا تشخیص داده شد !!!");
    lastTriggerTime = millis();
  }
  
  // اگر خوانش آنالوگ داریم
  if (analogVal > 0) {
    Serial.print("مقدار آنالوگ: ");
    Serial.println(analogVal);
    
    // تخمین فاصله بر اساس مقدار آنالوگ
    if (analogVal > 900) {
      Serial.println("فاصله: بسیار نزدیک (کمتر از 5mm)");
    } else if (analogVal > 700) {
      Serial.println("فاصله: نزدیک (5-15mm)");
    } else if (analogVal > sensitivity) {
      Serial.println("فاصله: متوسط (15-25mm)");
    } else {
      Serial.println("فاصله: دور (بیشتر از 25mm)");
    }
  }
}

void displayStatus(int digitalState, int analogVal) {
  Serial.println("------ وضعیت سیستم ------");
  Serial.print("وضعیت دیجیتال: ");
  Serial.println(digitalState == LOW ? "آهنربا حاضر" : "بدون آهنربا");
  
  if (analogVal > 0) {
    Serial.print("مقدار آنالوگ: ");
    Serial.println(analogVal);
  }
  
  Serial.print("حساسیت: ");
  Serial.println(sensitivity);
  
  Serial.print("آلارم: ");
  Serial.println(alarmEnabled ? "فعال" : "غیرفعال");
  
  Serial.print("زمان کار: ");
  Serial.print(millis() / 1000);
  Serial.println(" ثانیه");
  Serial.println("--------------------------");
}

void processSerialCommand() {
  String command = Serial.readStringUntil('\n');
  command.trim();
  
  if (command.length() > 0) {
    if (command.startsWith("S")) {
      int newSensitivity = command.substring(1).toInt();
      if (newSensitivity >= 100 && newSensitivity <= 900) {
        sensitivity = newSensitivity;
        Serial.print("حساسیت به ");
        Serial.print(sensitivity);
        Serial.println(" تنظیم شد");
      } else {
        Serial.println("خطا: حساسیت باید بین 100 تا 900 باشد");
      }
    } else if (command == "A0") {
      alarmEnabled = false;
      Serial.println("آلارم غیرفعال شد");
    } else if (command == "A1") {
      alarmEnabled = true;
      Serial.println("آلارم فعال شد");
    } else {
      Serial.println("دستور نامعتبر");
    }
  }
}

// سیستم امنیتی چند نقطه‌ای با رید سوییچ
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <SD.h>
#include <SoftwareSerial.h>

// تعریف پین‌ها
const int reedPins[] = {22, 24, 26, 28}; // 4 سنسور رید
const int relayPins[] = {30, 32, 34, 36}; // 4 رله
const int numSensors = 4;

// تعریف ماژول‌ها
LiquidCrystal_I2C lcd(0x27, 20, 4); // آدرس LCD
SoftwareSerial sim800l(10, 11); // RX, TX برای SIM800L

// متغیرهای سیستم
bool systemArmed = false;
bool sensorStates[numSensors] = {false, false, false, false};
bool lastSensorStates[numSensors] = {false, false, false, false};
unsigned long triggerTimes[numSensors] = {0, 0, 0, 0};
String locationNames[] = {"درب اصلی", "درب پشتی", "پنجره اتاق", "پنجره پذیرایی"};
String phoneNumbers[] = {"0912XXXXXXX", "0913XXXXXXX"}; // شماره‌های دریافت هشدار

void setup() {
  Serial.begin(9600);
  sim800l.begin(9600);
  
  // تنظیم پین‌ها
  for (int i = 0; i < numSensors; i++) {
    pinMode(reedPins[i], INPUT_PULLUP);
    pinMode(relayPins[i], OUTPUT);
    digitalWrite(relayPins[i], HIGH); // رله غیرفعال
  }
  
  // راه‌اندازی LCD
  lcd.init();
  lcd.backlight();
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("سیستم امنیتی");
  lcd.setCursor(0, 1);
  lcd.print("راه‌اندازی...");
  
  // راه‌اندازی SD کارت
  if (!SD.begin(53)) {
    lcd.setCursor(0, 2);
    lcd.print("SD Card Error!");
    Serial.println("SD Card initialization failed!");
  } else {
    Serial.println("SD Card initialized.");
    logEvent("سیستم راه‌اندازی شد");
  }
  
  delay(2000);
  lcd.clear();
  displayStatus();
  
  Serial.println("سیستم امنیتی چند نقطه‌ای آماده");
  Serial.println("دستورات:");
  Serial.println("ARM: فعال کردن سیستم");
  Serial.println("DISARM: غیرفعال کردن سیستم");
  Serial.println("STATUS: نمایش وضعیت");
}

void loop() {
  // پردازش دستورات سریال
  if (Serial.available() > 0) {
    processSerialCommand();
  }
  
  // خواندن سنسورها
  readSensors();
  
  // بررسی تغییر وضعیت سنسورها
  checkSensorChanges();
  
  // به‌روزرسانی نمایشگر هر 500ms
  static unsigned long lastDisplayUpdate = 0;
  if (millis() - lastDisplayUpdate > 500) {
    displayStatus();
    lastDisplayUpdate = millis();
  }
  
  delay(100);
}

void readSensors() {
  for (int i = 0; i < numSensors; i++) {
    // با Pull-up، LOW یعنی آهنربا حاضر (درب بسته)
    sensorStates[i] = (digitalRead(reedPins[i]) == LOW);
  }
}

void checkSensorChanges() {
  if (!systemArmed) return;
  
  for (int i = 0; i < numSensors; i++) {
    // اگر سنسور تغییر وضعیت داد (از بسته به باز)
    if (!sensorStates[i] && lastSensorStates[i]) {
      triggerTimes[i] = millis();
      
      String message = locationNames[i] + " باز شد!";
      Serial.println("!!! هشدار: " + message);
      
      // فعال کردن رله مربوطه (آلارم محلی)
      digitalWrite(relayPins[i], LOW);
      
      // ارسال SMS
      sendSMS(message);
      
      // ذخیره در لاگ
      logEvent(message);
      
      // نمایش روی LCD
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("!!! هشدار !!!");
      lcd.setCursor(0, 1);
      lcd.print(locationNames[i]);
      lcd.setCursor(0, 2);
      lcd.print("باز شد");
      lcd.setCursor(0, 3);
      lcd.print("زمان: " + getTimeString());
    }
    
    // اگر سنسور دوباره بسته شد
    if (sensorStates[i] && !lastSensorStates[i] && triggerTimes[i] > 0) {
      unsigned long openDuration = millis() - triggerTimes[i];
      String message = locationNames[i] + " بسته شد (باز بود: " + 
                      String(openDuration/1000.0, 1) + " ثانیه)";
      Serial.println(message);
      
      // غیرفعال کردن رله
      digitalWrite(relayPins[i], HIGH);
      
      logEvent(message);
      
      triggerTimes[i] = 0;
    }
    
    lastSensorStates[i] = sensorStates[i];
  }
}

void displayStatus() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("وضعیت: ");
  lcd.print(systemArmed ? "مسلح" : "غیرمسلح");
  
  for (int i = 0; i < numSensors; i++) {
    lcd.setCursor(0, i + 1);
    lcd.print(String(i+1) + ":");
    lcd.print(sensorStates[i] ? "بسته" : "باز  ");
  }
}

void processSerialCommand() {
  String command = Serial.readStringUntil('\n');
  command.trim();
  command.toUpperCase();
  
  if (command == "ARM") {
    systemArmed = true;
    Serial.println("سیستم مسلح شد");
    logEvent("سیستم مسلح شد");
    sendSMS("سیستم امنیتی منزل فعال شد");
  } 
  else if (command == "DISARM") {
    systemArmed = false;
    Serial.println("سیستم غیرمسلح شد");
    logEvent("سیستم غیرمسلح شد");
    sendSMS("سیستم امنیتی منزل غیرفعال شد");
  }
  else if (command == "STATUS") {
    Serial.println("====== وضعیت سنسورها ======");
    for (int i = 0; i < numSensors; i++) {
      Serial.print(locationNames[i] + ": ");
      Serial.println(sensorStates[i] ? "بسته" : "باز");
    }
    Serial.println("سیستم: " + String(systemArmed ? "مسلح" : "غیرمسلح"));
    Serial.println("===========================");
  }
}

void sendSMS(String message) {
  sim800l.println("AT+CMGF=1"); // تنظیم حالت متن
  delay(100);
  
  for (int i = 0; i < 2; i++) {
    sim800l.println("AT+CMGS=\"" + phoneNumbers[i] + "\"");
    delay(100);
    sim800l.print(message);
    delay(100);
    sim800l.write(26); // Ctrl+Z برای ارسال
    delay(1000);
  }
  
  logEvent("SMS ارسال شد: " + message);
}

void logEvent(String event) {
  File logFile = SD.open("security.log", FILE_WRITE);
  if (logFile) {
    logFile.println(getTimeString() + " - " + event);
    logFile.close();
  }
}

String getTimeString() {
  unsigned long seconds = millis() / 1000;
  unsigned long minutes = seconds / 60;
  unsigned long hours = minutes / 60;
  seconds %= 60;
  minutes %= 60;
  
  return String(hours) + ":" + 
         (minutes < 10 ? "0" : "") + String(minutes) + ":" + 
         (seconds < 10 ? "0" : "") + String(seconds);
}

فاصله کار ≈ (قدرت آهنربا) / (حساسیت رید سوییچ)
مثال: آهنربای نئودیمیوم N52 با قدرت 5000 گاوس
و رید سوییچ با حساسیت 20AT
فاصله ≈ 5000 / (20 × 80) ≈ 3.1cm

// استفاده از دیود Snubber برای محافظت
/*
برای بارهای DC القایی (مانند رله، سولنوئید):
- دیود 1N4007 موازی با بار
- آند به مثبت، کاتد به منفی

برای بارهای AC:
- واریستور (MOV) موازی با بار
- RC snubber (100Ω + 0.1μF)
*/