ماژول سنسور صدا

ماژول سنسور صدا → آردوینو
---------------------------------
VCC  → 5V یا 3.3V
GND  → GND
DO   → پایه دیجیتال (مثلاً D2) برای تشخیص صدا
AO   → پایه آنالوگ (مثلاً A0) برای سطح شدت صوت

/*
 * کد پایه برای تشخیص صدا با خروجی دیجیتال
 * اتصال: پایه DO ماژول به D2 آردوینو
 */

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

int sensorState = 0;           // وضعیت فعلی سنسور
int lastState = 0;             // وضعیت قبلی سنسور
int soundCount = 0;            // شمارنده صداها

void setup() {
  Serial.begin(9600);
  pinMode(soundSensorPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  
  Serial.println("==================================");
  Serial.println("   Sound Sensor Basic Test");
  Serial.println("==================================");
  Serial.println("Listening for sounds...");
  Serial.println();
}

void loop() {
  // خواندن وضعیت سنسور
  // توجه: در اکثر ماژول‌ها، تشخیص صدا = LOW
  sensorState = digitalRead(soundSensorPin);
  
  // تشخیص شروع صدا
  if (sensorState == LOW && lastState == HIGH) {
    soundCount++;
    digitalWrite(ledPin, HIGH);
    
    Serial.print("Sound #");
    Serial.print(soundCount);
    Serial.print(" detected at ");
    Serial.print(millis() / 1000.0, 2);
    Serial.println(" seconds");
    
    // فعال کردن بوق به مدت کوتاه
    tone(buzzerPin, 1500, 200);
  }
  
  // تشخیص پایان صدا
  if (sensorState == HIGH && lastState == LOW) {
    digitalWrite(ledPin, LOW);
    Serial.println("  Sound ended");
    Serial.println("------------------");
  }
  
  // ذخیره وضعیت برای چرخه بعد
  lastState = sensorState;
  
  delay(10); // تأخیر کوتاه برای پایداری
}

/*
 * اندازه‌گیری و نمایش سطح شدت صوت
 * اتصال: پایه AO ماژول به A0 آردوینو
 */

const int analogPin = A0;      // پایه آنالوگ سنسور
const int sampleWindow = 50;   // پنجره نمونه‌برداری (ms)
const int redLed = 11;         // LED قرمز برای سطح بالا
const int yellowLed = 12;      // LED زرد برای سطح متوسط
const int greenLed = 13;       // LED سبز برای سطح پایین

// آستانه‌های سطح صوت (بر اساس کالیبراسیون تنظیم شود)
const int quietThreshold = 50;
const int normalThreshold = 150;
const int loudThreshold = 300;
const int veryLoudThreshold = 500;

// متغیرهای آماری
float maxLevel = 0;
float minLevel = 1024;
float longTermAvg = 0;
int sampleCount = 0;

void setup() {
  Serial.begin(9600);
  pinMode(redLed, OUTPUT);
  pinMode(yellowLed, OUTPUT);
  pinMode(greenLed, OUTPUT);
  
  // خاموش کردن همه LED‌ها
  digitalWrite(redLed, LOW);
  digitalWrite(yellowLed, LOW);
  digitalWrite(greenLed, LOW);
  
  Serial.println("=======================================");
  Serial.println("   Sound Intensity Measurement");
  Serial.println("=======================================");
  Serial.println("Time\tLevel\tMin\tMax\tAvg\tStatus");
  Serial.println("-----\t-----\t---\t---\t---\t------");
}

void loop() {
  unsigned long startTime = millis();
  unsigned int peakToPeak = 0;
  unsigned int signalMax = 0;
  unsigned int signalMin = 1024;
  
  // جمع‌آوری نمونه‌ها در طول پنجره زمانی
  while (millis() - startTime < sampleWindow) {
    int sample = analogRead(analogPin);
    
    if (sample < 1024) { // حذف مقادیر نامعتبر
      if (sample > signalMax) {
        signalMax = sample;
      }
      if (sample < signalMin) {
        signalMin = sample;
      }
    }
  }
  
  // محاسبه دامنه
  peakToPeak = signalMax - signalMin;
  
  // به‌روزرسانی آمار
  if (peakToPeak > maxLevel) maxLevel = peakToPeak;
  if (peakToPeak < minLevel) minLevel = peakToPeak;
  
  // محاسبه میانگین بلندمدت
  longTermAvg = (longTermAvg * sampleCount + peakToPeak) / (sampleCount + 1);
  if (sampleCount < 10000) sampleCount++;
  
  // نمایش نتایج
  Serial.print(millis() / 1000.0, 1);
  Serial.print("\t");
  Serial.print(peakToPeak);
  Serial.print("\t");
  Serial.print(minLevel);
  Serial.print("\t");
  Serial.print(maxLevel);
  Serial.print("\t");
  Serial.print(longTermAvg, 0);
  Serial.print("\t");
  
  // کنترل LED‌ها بر اساس سطح صوت
  digitalWrite(greenLed, LOW);
  digitalWrite(yellowLed, LOW);
  digitalWrite(redLed, LOW);
  
  if (peakToPeak < quietThreshold) {
    Serial.println("Quiet");
    digitalWrite(greenLed, HIGH);
  } 
  else if (peakToPeak < normalThreshold) {
    Serial.println("Normal");
    digitalWrite(greenLed, HIGH);
    digitalWrite(yellowLed, HIGH);
  }
  else if (peakToPeak < loudThreshold) {
    Serial.println("Loud");
    digitalWrite(yellowLed, HIGH);
  }
  else if (peakToPeak < veryLoudThreshold) {
    Serial.println("Very Loud");
    digitalWrite(yellowLed, HIGH);
    digitalWrite(redLed, HIGH);
  }
  else {
    Serial.println("DANGER - Too Loud!");
    // چشمک زدن LED قرمز
    digitalWrite(redLed, HIGH);
    delay(100);
    digitalWrite(redLed, LOW);
  }
  
  delay(100); // تأخیر بین اندازه‌گیری‌ها
}

/*
 * سیستم کنترل لامپ با تشخیص الگوی کف‌زدن
 * نیاز به 2 کف متوالی با فاصله مشخص
 */

const int soundDigitalPin = 2;
const int soundAnalogPin = A0;
const int relayPin = 7;           // کنترل رله لامپ
const int statusLed = 13;         // LED وضعیت

// تنظیمات تشخیص کف‌زدن
const int clapThreshold = 400;    // آستانه تشخیص کف
const unsigned long clapTimeout = 2000;  // زمان‌ات الگو
const unsigned long clapGapMin = 200;    // حداقل فاصله بین کف‌ها
const unsigned long clapGapMax = 800;    // حداکثر فاصله بین کف‌ها

// متغیرهای تشخیص الگو
int clapCount = 0;
unsigned long firstClapTime = 0;
unsigned long lastClapTime = 0;
bool lightOn = false;             // وضعیت لامپ

void setup() {
  Serial.begin(9600);
  pinMode(soundDigitalPin, INPUT);
  pinMode(relayPin, OUTPUT);
  pinMode(statusLed, OUTPUT);
  
  // لامپ ابتدا خاموش است
  digitalWrite(relayPin, LOW);
  digitalWrite(statusLed, LOW);
  
  Serial.println("==================================");
  Serial.println("   Clap-Controlled Light System");
  Serial.println("==================================");
  Serial.println("Clap twice quickly to toggle light");
  Serial.println();
}

void loop() {
  int analogValue = analogRead(soundAnalogPin);
  
  // تشخیص کف‌زدن (مقدار آنالوگ از آستانه بیشتر شود)
  if (analogValue > clapThreshold) {
    unsigned long currentTime = millis();
    unsigned long timeSinceLastClap = currentTime - lastClapTime;
    
    // بررسی Debouncing
    delay(50); // تأخیر برای رد کردن نویزهای کوتاه
    int confirmValue = analogRead(soundAnalogPin);
    
    if (confirmValue > clapThreshold) {
      // کف معتبر تشخیص داده شد
      
      if (clapCount == 0) {
        // اولین کف
        clapCount = 1;
        firstClapTime = currentTime;
        lastClapTime = currentTime;
        
        Serial.println("Clap 1 detected");
        blinkLed(1);
      }
      else if (timeSinceLastClap > clapGapMin && timeSinceLastClap < clapGapMax) {
        // کف دوم در محدوده زمانی مناسب
        clapCount++;
        lastClapTime = currentTime;
        
        Serial.print("Clap ");
        Serial.print(clapCount);
        Serial.println(" detected");
        blinkLed(clapCount);
      }
      else {
        // فاصله زمانی نامناسب - ریست شمارنده
        clapCount = 0;
        Serial.println("Invalid clap interval - Reset");
      }
    }
    
    // تأخیر برای جلوگیری از تشخیص چندگانه
    delay(200);
  }
  
  // بررسی زمان‌ات و کامل بودن الگو
  if (clapCount > 0) {
    unsigned long currentTime = millis();
    
    // بررسی زمان‌ات
    if (currentTime - firstClapTime > clapTimeout) {
      Serial.println("Pattern timeout");
      clapCount = 0;
    }
    
    // اگر 2 کف با فاصله مناسب تشخیص داده شد
    if (clapCount >= 2) {
      // تغییر وضعیت لامپ
      lightOn = !lightOn;
      digitalWrite(relayPin, lightOn ? HIGH : LOW);
      
      Serial.print("Light turned ");
      Serial.println(lightOn ? "ON" : "OFF");
      Serial.println("--------------------");
      
      // نمایش وضعیت با LED
      digitalWrite(statusLed, lightOn);
      
      // ریست برای تشخیص بعدی
      clapCount = 0;
      
      // تأخیر برای جلوگیری از تشخیص ناخواسته
      delay(1000);
    }
  }
  
  // نمایش دوره‌ای سطح صدا (برای تنظیم آستانه)
  static unsigned long lastDisplay = 0;
  if (millis() - lastDisplay > 5000) {
    Serial.print("Current sound level: ");
    Serial.println(analogRead(soundAnalogPin));
    lastDisplay = millis();
  }
}

// تابع برای چشمک زدن LED به تعداد مشخص
void blinkLed(int times) {
  for (int i = 0; i < times; i++) {
    digitalWrite(statusLed, HIGH);
    delay(100);
    digitalWrite(statusLed, LOW);
    if (i < times - 1) delay(100);
  }
}

/*
 * سیستم تشخیص نویز غیرعادی برای امنیت
 * هشدار در صورت وجود صداهای بلند ناگهانی
 */

const int soundAnalogPin = A0;
const int alarmPin = 8;           // بوق هشدار
const int warningLed = 9;         // LED هشدار زرد
const int alarmLed = 10;          // LED هشدار قرمز
const int resetButton = 3;        // دکمه ریست سیستم

// تنظیمات سیستم
const int baselineSamples = 100;  // تعداد نمونه‌ها برای پایه‌گذاری
const float alarmMultiplier = 3.0; // ضریب برای تشخیص نویز غیرعادی
const unsigned long alarmDuration = 10000; // مدت هشدار (ms)

float noiseBaseline = 0;          // سطح نویز پایه
float currentNoiseLevel = 0;      // سطح نویز فعلی
bool alarmActive = false;         // وضعیت هشدار
unsigned long alarmStartTime = 0; // زمان شروع هشدار

void setup() {
  Serial.begin(9600);
  pinMode(alarmPin, OUTPUT);
  pinMode(warningLed, OUTPUT);
  pinMode(alarmLed, OUTPUT);
  pinMode(resetButton, INPUT_PULLUP);
  
  Serial.println("==================================");
  Serial.println("   Abnormal Noise Detection System");
  Serial.println("==================================");
  
  // کالیبراسیون سطح نویز پایه
  calibrateBaseline();
  
  Serial.println("System calibrated and active");
  Serial.println("Monitoring for abnormal noises...");
  Serial.println();
}

void loop() {
  // خواندن سطح صوت فعلی
  currentNoiseLevel = readNoiseLevel();
  
  // بررسی دکمه ریست
  if (digitalRead(resetButton) == LOW) {
    resetAlarm();
    delay(500); // Debouncing
  }
  
  // اگر هشدار فعال است
  if (alarmActive) {
    digitalWrite(alarmLed, HIGH);
    digitalWrite(warningLed, ((millis() / 500) % 2 == 0)); // چشمک زدن
    
    // بوق هشدار
    tone(alarmPin, 1000, 200);
    delay(250);
    tone(alarmPin, 1500, 200);
    
    // بررسی پایان زمان هشدار
    if (millis() - alarmStartTime > alarmDuration) {
      resetAlarm();
    }
  }
  else {
    // بررسی سطح نویز
    if (currentNoiseLevel > noiseBaseline * alarmMultiplier) {
      triggerAlarm();
    }
    
    // نمایش وضعیت عادی
    digitalWrite(alarmLed, LOW);
    
    // LED هشدار ملایم در صورت نویز بالا
    if (currentNoiseLevel > noiseBaseline * 2.0) {
      digitalWrite(warningLed, HIGH);
    } else {
      digitalWrite(warningLed, LOW);
    }
  }
  
  // نمایش اطلاعات دوره‌ای
  static unsigned long lastReport = 0;
  if (millis() - lastReport > 2000) {
    Serial.print("Baseline: ");
    Serial.print(noiseBaseline, 0);
    Serial.print(" | Current: ");
    Serial.print(currentNoiseLevel, 0);
    Serial.print(" | Ratio: ");
    Serial.print(currentNoiseLevel / noiseBaseline, 1);
    Serial.print(" | Alarm: ");
    Serial.println(alarmActive ? "ACTIVE" : "Inactive");
    
    lastReport = millis();
  }
  
  delay(100);
}

// کالیبراسیون سطح نویز پایه
void calibrateBaseline() {
  Serial.println("Calibrating noise baseline...");
  Serial.println("Please ensure quiet environment for 5 seconds");
  
  digitalWrite(warningLed, HIGH);
  
  long total = 0;
  for (int i = 0; i < baselineSamples; i++) {
    total += analogRead(soundAnalogPin);
    delay(50);
    
    // نمایش پیشرفت
    if (i % 20 == 0) {
      Serial.print(".");
    }
  }
  
  noiseBaseline = total / (float)baselineSamples;
  
  digitalWrite(warningLed, LOW);
  
  Serial.println();
  Serial.print("Baseline calibration complete: ");
  Serial.println(noiseBaseline, 0);
}

// خواندن سطح نویز با میانگین‌گیری
float readNoiseLevel() {
  long total = 0;
  for (int i = 0; i < 10; i++) {
    total += analogRead(soundAnalogPin);
    delay(5);
  }
  return total / 10.0;
}

// فعال‌سازی هشدار
void triggerAlarm() {
  alarmActive = true;
  alarmStartTime = millis();
  
  Serial.println("!!! ABNORMAL NOISE DETECTED !!!");
  Serial.print("Level: ");
  Serial.print(currentNoiseLevel, 0);
  Serial.print(" (");
  Serial.print(currentNoiseLevel / noiseBaseline, 1);
  Serial.println("x baseline)");
  Serial.println("----------------------------------");
}

// غیرفعال‌سازی هشدار
void resetAlarm() {
  alarmActive = false;
  digitalWrite(alarmLed, LOW);
  digitalWrite(warningLed, LOW);
  noTone(alarmPin);
  
  Serial.println("Alarm reset");
  Serial.println();
}

// اضافه کردن فیلتر دیجیتال
float applyLowPassFilter(float input, float previous, float alpha) {
  return alpha * input + (1 - alpha) * previous;
}

// میانگین‌گیری چندگانه برای کاهش نویز
int readStableAnalog(int pin, int samples) {
  long total = 0;
  for (int i = 0; i < samples; i++) {
    total += analogRead(pin);
    delay(2);
  }
  return total / samples;
}

// تولید فراصوت با تشخیص پارس

// ثبت خروپف و حرکات در خواب

// تبدیل صداهای مهم به نور یا لرزش

// کنترل ربات یا ماشین با دستورات صوتی

// اندازه‌گیری دقت نوت‌های موسیقی