ماژول سنسور حساسیت میکروفون

ماژول میکروفون ← آردوینو
VCC ← 5V یا 3.3V
GND ← GND
AO ← پایه آنالوگ (مثلاً A0) - برای اندازه‌گیری شدت صوت
DO ← پایه دیجیتال (مثلاً D2) - برای تشخیص صدا

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

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

int soundState = HIGH;          // وضعیت فعلی (HIGH = سکوت)
int lastSoundState = HIGH;      // وضعیت قبلی
unsigned long soundStartTime = 0; // زمان شروع صدا
int soundCount = 0;             // شمارش تعداد صداها

void setup() {
  Serial.begin(9600);
  pinMode(micDigitalPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(buzzerPin, OUTPUT);
  
  Serial.println("Sound Detection Module Test");
  Serial.println("===========================");
  Serial.println("Waiting for sound...");
}

void loop() {
  // خواندن وضعیت سنسور
  // توجه: در بیشتر ماژول‌ها، وجود صدا = LOW، سکوت = HIGH
  soundState = digitalRead(micDigitalPin);
  
  // تشخیص شروع صدا (لبه پایین‌رونده)
  if (soundState == LOW && lastSoundState == HIGH) {
    soundStartTime = millis();
    soundCount++;
    
    Serial.print("Sound detected! #");
    Serial.print(soundCount);
    Serial.print(" at ");
    Serial.print(millis() / 1000.0, 2);
    Serial.println("s");
    
    // فعال کردن LED و بوق
    digitalWrite(ledPin, HIGH);
    tone(buzzerPin, 1000, 100); // بوق 100ms
  }
  
  // تشخیص پایان صدا (لبه بالارونده)
  if (soundState == HIGH && lastSoundState == LOW) {
    unsigned long soundDuration = millis() - soundStartTime;
    
    Serial.print("Sound ended. Duration: ");
    Serial.print(soundDuration);
    Serial.println("ms");
    
    digitalWrite(ledPin, LOW);
  }
  
  // ذخیره وضعیت برای تشخیص لبه‌ها
  lastSoundState = soundState;
  
  delay(10); // تأخیر کوتاه برای پایداری
}

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

const int micAnalogPin = A0;    // پایه خروجی آنالوگ
const int sampleWindow = 50;    // پنجره نمونه‌برداری (میلی‌ثانیه)
const int noiseThreshold = 50;  // آستانه نویز (بر اساس آزمایش تنظیم شود)

unsigned int sample;
float soundLevel = 0;
float maxLevel = 0;
float minLevel = 1024;
float averageLevel = 0;
int sampleCount = 0;

// برای نمایش گرافیکی در Serial Plotter
const int historySize = 100;
float levelHistory[historySize];
int historyIndex = 0;

void setup() {
  Serial.begin(115200); // نرخ بالاتر برای نمایش سریع
  
  // Initialize history array
  for (int i = 0; i < historySize; i++) {
    levelHistory[i] = 0;
  }
  
  Serial.println("Sound Level Meter with Microphone Module");
  Serial.println("========================================");
  Serial.println("Time(s)\tCurrent\tMax\tMin\tAvg\tStatus");
}

void loop() {
  unsigned long startMillis = millis();
  float peakToPeak = 0;
  unsigned int signalMax = 0;
  unsigned int signalMin = 1024;
  
  // نمونه‌برداری در طول پنجره زمانی
  while (millis() - startMillis < sampleWindow) {
    sample = analogRead(micAnalogPin);
    
    if (sample < 1024) { // حذف مقادیر نامعتبر
      if (sample > signalMax) {
        signalMax = sample;
      }
      if (sample < signalMin) {
        signalMin = sample;
      }
    }
  }
  
  // محاسبه دامنه peak-to-peak
  peakToPeak = signalMax - signalMin;
  
  // محاسبه سطح صوت نسبی (0-100%)
  soundLevel = (peakToPeak * 100.0) / 1024.0;
  
  // به‌روزرسانی آمار
  if (soundLevel > maxLevel) maxLevel = soundLevel;
  if (soundLevel < minLevel) minLevel = soundLevel;
  
  // محاسبه میانگین متحرک
  averageLevel = (averageLevel * sampleCount + soundLevel) / (sampleCount + 1);
  if (sampleCount < 1000) sampleCount++;
  
  // ذخیره در تاریخچه برای نمودار
  levelHistory[historyIndex] = soundLevel;
  historyIndex = (historyIndex + 1) % historySize;
  
  // نمایش نتایج
  Serial.print(millis() / 1000.0, 1);
  Serial.print("\t");
  Serial.print(soundLevel, 1);
  Serial.print("\t");
  Serial.print(maxLevel, 1);
  Serial.print("\t");
  Serial.print(minLevel, 1);
  Serial.print("\t");
  Serial.print(averageLevel, 1);
  Serial.print("\t");
  
  // تفسیر سطح صوت
  if (soundLevel < noiseThreshold) {
    Serial.println("Quiet");
  } else if (soundLevel < noiseThreshold + 20) {
    Serial.println("Normal");
  } else if (soundLevel < noiseThreshold + 40) {
    Serial.println("Loud");
  } else {
    Serial.println("VERY LOUD!");
  }
  
  // نمایش گرافیکی در Serial Plotter
  if (Serial.availableForWrite() > 200) {
    Serial.print("Graph:");
    for (int i = 0; i < historySize; i++) {
      int idx = (historyIndex + i) % historySize;
      Serial.print(" ");
      Serial.print(levelHistory[idx], 0);
    }
    Serial.println();
  }
  
  delay(100); // تأخیر بین اندازه‌گیری‌ها
}

// آردوینو - کنترل روشنایی با تشخیص الگوی کف‌زدن
// اتصال: DO به D2، AO به A0

const int micDigitalPin = 2;
const int micAnalogPin = A0;
const int relayPin = 7;      // کنترل لامپ
const int statusLed = 13;

// تنظیمات تشخیص الگو
const unsigned long patternTimeout = 2000;  // زمان‌ات الگو (ms)
const int clapThreshold = 300;             // آستانه تشخیص کف (مقدار آنالوگ)
const unsigned long clapMaxDuration = 500; // حداکثر مدت کف (ms)
const unsigned long clapGapMin = 100;      // حداقل فاصله بین کف‌ها (ms)
const unsigned long clapGapMax = 1000;     // حداکثر فاصله بین کف‌ها (ms)

// الگوی موردنظر: دو کف با فاصله کوتاه
const int patternClaps = 2;

// متغیرهای تشخیص الگو
int clapCount = 0;
unsigned long lastClapTime = 0;
unsigned long patternStartTime = 0;
bool lightState = false;

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

void loop() {
  int digitalState = digitalRead(micDigitalPin);
  int analogValue = analogRead(micAnalogPin);
  
  // تشخیص کف‌زدن
  if (digitalState == LOW && analogValue > clapThreshold) {
    unsigned long currentTime = millis();
    unsigned long timeSinceLastClap = currentTime - lastClapTime;
    
    // Debouncing و بررسی مدت کف
    delay(50);
    if (digitalRead(micDigitalPin) == HIGH) {
      // کف معتبر تشخیص داده شد
      
      // بررسی اینکه آیا کف اول است یا ادامه الگو
      if (clapCount == 0) {
        // شروع الگوی جدید
        clapCount = 1;
        patternStartTime = currentTime;
        Serial.println("Clap 1 detected");
      } 
      else if (timeSinceLastClap > clapGapMin && timeSinceLastClap < clapGapMax) {
        // کف دوم در فاصله مناسب
        clapCount++;
        Serial.print("Clap ");
        Serial.print(clapCount);
        Serial.println(" detected");
      }
      
      lastClapTime = currentTime;
      
      // بازخورد LED
      digitalWrite(statusLed, HIGH);
      delay(100);
      digitalWrite(statusLed, LOW);
    }
  }
  
  // بررسی کامل شدن الگو
  if (clapCount > 0) {
    unsigned long currentTime = millis();
    
    // بررسی زمان‌ات الگو
    if (currentTime - patternStartTime > patternTimeout) {
      Serial.println("Pattern timeout - resetting");
      clapCount = 0;
    }
    
    // اگر الگو کامل شد
    if (clapCount >= patternClaps) {
      // بررسی فاصله مناسب بین کف‌های آخر
      if (currentTime - lastClapTime < clapGapMax) {
        // تغییر وضعیت لامپ
        lightState = !lightState;
        digitalWrite(relayPin, lightState ? HIGH : LOW);
        
        Serial.print("Pattern complete! Light turned ");
        Serial.println(lightState ? "ON" : "OFF");
        
        // بازخورد LED
        for (int i = 0; i < 3; i++) {
          digitalWrite(statusLed, HIGH);
          delay(100);
          digitalWrite(statusLed, LOW);
          delay(100);
        }
      }
      
      // ریست شمارنده
      clapCount = 0;
    }
  }
  
  // نمایش وضعیت آنالوگ (برای تنظیم آستانه)
  static unsigned long lastDisplayTime = 0;
  if (millis() - lastDisplayTime > 2000) {
    Serial.print("Analog level: ");
    Serial.println(analogRead(micAnalogPin));
    lastDisplayTime = millis();
  }
  
  delay(10); // تأخیر کوتاه
}

// آردوینو - تشخیص الگوهای صوتی پیچیده‌تر
// مناسب برای دستورات صوتی ساده

#include <FHT.h> // کتابخانه تبدیل فوریه سریع

const int micAnalogPin = A0;
const int fftSize = 256; // اندازه تبدیل فوریه

// ذخیره الگوهای شناخته شده
float pattern1[fftSize/2]; // الگوی صوتی 1
float pattern2[fftSize/2]; // الگوی صوتی 2

void setup() {
  Serial.begin(115200);
  
  Serial.println("Audio Pattern Recognition");
  Serial.println("========================");
  
  // آموزش الگوها (باید با صداهای واقعی جایگزین شود)
  Serial.println("Say 'ON' to train pattern 1...");
  delay(3000);
  trainPattern(pattern1, "ON");
  
  Serial.println("Say 'OFF' to train pattern 2...");
  delay(3000);
  trainPattern(pattern2, "OFF");
  
  Serial.println("Training complete. Ready for recognition...");
}

void loop() {
  if (detectSound()) {
    float currentPattern[fftSize/2];
    captureAudioPattern(currentPattern);
    
    float similarity1 = comparePatterns(currentPattern, pattern1);
    float similarity2 = comparePatterns(currentPattern, pattern2);
    
    Serial.print("Similarity to ON: ");
    Serial.print(similarity1, 2);
    Serial.print(", to OFF: ");
    Serial.print(similarity2, 2);
    
    if (similarity1 > 0.7 && similarity1 > similarity2) {
      Serial.println(" -> Command: ON");
      // انجام عمل مربوط به ON
    } 
    else if (similarity2 > 0.7 && similarity2 > similarity1) {
      Serial.println(" -> Command: OFF");
      // انجام عمل مربوط به OFF
    } 
    else {
      Serial.println(" -> Unknown command");
    }
  }
  
  delay(100);
}

bool detectSound() {
  // تشخیص وجود صدا
  unsigned long startTime = millis();
  unsigned int maxVal = 0;
  
  while (millis() - startTime < 100) {
    int val = analogRead(micAnalogPin);
    if (val > maxVal) maxVal = val;
  }
  
  return (maxVal > 200); // آستانه تشخیص صدا
}

void trainPattern(float pattern[], const char* label) {
  Serial.print("Training ");
  Serial.println(label);
  
  captureAudioPattern(pattern);
  Serial.println("Pattern saved.");
}

void captureAudioPattern(float pattern[]) {
  // نمونه‌برداری و تبدیل فوریه
  for (int i = 0; i < fftSize; i++) {
    while (true) {
      int sample = analogRead(micAnalogPin);
      if (sample < 1024) {
        fht_input[i] = sample;
        break;
      }
    }
  }
  
  // انجام تبدیل فوریه
  fht_window();
  fht_reorder();
  fht_run();
  fht_mag_lin();
  
  // ذخیره الگو
  for (int i = 0; i < fftSize/2; i++) {
    pattern[i] = fht_lin_out[i];
  }
}

float comparePatterns(float pattern1[], float pattern2[]) {
  // محاسبه شباهت دو الگو (ضریب همبستگی)
  float sum1 = 0, sum2 = 0, sum12 = 0;
  float sum1Sq = 0, sum2Sq = 0;
  
  for (int i = 0; i < fftSize/2; i++) {
    sum1 += pattern1[i];
    sum2 += pattern2[i];
    sum12 += pattern1[i] * pattern2[i];
    sum1Sq += pattern1[i] * pattern1[i];
    sum2Sq += pattern2[i] * pattern2[i];
  }
  
  int n = fftSize/2;
  float numerator = n * sum12 - sum1 * sum2;
  float denominator = sqrt((n * sum1Sq - sum1 * sum1) * (n * sum2Sq - sum2 * sum2));
  
  if (denominator == 0) return 0;
  return numerator / denominator;
}

// کد کالیبراسیون نویز محیط
void calibrateNoiseFloor() {
  Serial.println("Calibrating noise floor... Stay quiet for 5 seconds.");
  delay(5000);
  
  long sum = 0;
  for (int i = 0; i < 100; i++) {
    sum += analogRead(micAnalogPin);
    delay(10);
  }
  
  int noiseFloor = sum / 100;
  Serial.print("Noise floor: ");
  Serial.println(noiseFloor);
  Serial.print("Recommended threshold: ");
  Serial.println(noiseFloor + 50);
}

// فیلتر میانگین متحرک
float movingAverageFilter(float newValue) {
  static float buffer[10];
  static int index = 0;
  static float sum = 0;
  
  sum -= buffer[index];
  buffer[index] = newValue;
  sum += newValue;
  index = (index + 1) % 10;
  
  return sum / 10.0;
}

// اندازه‌گیری و نمایش سطح صوت به dB

// ارسال هشدار هنگام تشخیص صداهای غیرعادی

// کنترل حرکت ربات با دستورات صوتی ساده

// ضبط زمان وقوع صداهای مهم در محیط

// روشن کردن چراغ و پخش لالایی با گریه نوزاد