ماژول بازر ← آردوینو
----------------------
VCC  → 5V
GND  → GND
I/O  → پایه PWM (مثلاً D9)

/*
 * تولید بوق ساده با بازر غیرفعال
 * اتصال: پایه سیگنال به D9
 */

const int buzzerPin = 9;  // پایه اتصال بازر

void setup() {
  pinMode(buzzerPin, OUTPUT);
  Serial.begin(9600);
  
  Serial.println("========================================");
  Serial.println("   Passive Buzzer Basic Test");
  Serial.println("========================================");
  Serial.println("Producing test tones...");
}

void loop() {
  // بوق کوتاه 1kHz
  Serial.println("Short beep: 1kHz, 200ms");
  tone(buzzerPin, 1000, 200); // فرکانس، مدت (میلی‌ثانیه)
  delay(500);
  
  // بوق با فرکانس متوسط
  Serial.println("Medium beep: 2kHz, 300ms");
  tone(buzzerPin, 2000, 300);
  delay(500);
  
  // بوق با فرکانس بالا
  Serial.println("High beep: 3kHz, 400ms");
  tone(buzzerPin, 3000, 400);
  delay(500);
  
  // افکت آژیر
  Serial.println("Siren effect...");
  sirenEffect();
  
  delay(1000);
}

void sirenEffect() {
  // افکت آژیر پلیس
  for (int i = 1000; i <= 2000; i += 50) {
    tone(buzzerPin, i, 50);
    delay(10);
  }
  
  for (int i = 2000; i >= 1000; i -= 50) {
    tone(buzzerPin, i, 50);
    delay(10);
  }
  
  noTone(buzzerPin); // قطع صدا
}

/*
 * تولید ملودی‌های معروف با بازر غیرفعال
 * شامل چند آهنگ معروف
 */

const int buzzerPin = 9;

// فرکانس‌های نت‌های موسیقی (هرتز)
#define NOTE_B0  31
#define NOTE_C1  33
#define NOTE_CS1 35
#define NOTE_D1  37
#define NOTE_DS1 39
#define NOTE_E1  41
#define NOTE_F1  44
#define NOTE_FS1 46
#define NOTE_G1  49
#define NOTE_GS1 52
#define NOTE_A1  55
#define NOTE_AS1 58
#define NOTE_B1  62
#define NOTE_C2  65
#define NOTE_CS2 69
#define NOTE_D2  73
#define NOTE_DS2 78
#define NOTE_E2  82
#define NOTE_F2  87
#define NOTE_FS2 93
#define NOTE_G2  98
#define NOTE_GS2 104
#define NOTE_A2  110
#define NOTE_AS2 117
#define NOTE_B2  123
#define NOTE_C3  131
#define NOTE_CS3 139
#define NOTE_D3  147
#define NOTE_DS3 156
#define NOTE_E3  165
#define NOTE_F3  175
#define NOTE_FS3 185
#define NOTE_G3  196
#define NOTE_GS3 208
#define NOTE_A3  220
#define NOTE_AS3 233
#define NOTE_B3  247
#define NOTE_C4  262  // دو میانی
#define NOTE_CS4 277
#define NOTE_D4  294
#define NOTE_DS4 311
#define NOTE_E4  330
#define NOTE_F4  349
#define NOTE_FS4 370
#define NOTE_G4  392
#define NOTE_GS4 415
#define NOTE_A4  440
#define NOTE_AS4 466
#define NOTE_B4  494
#define NOTE_C5  523
#define NOTE_CS5 554
#define NOTE_D5  587
#define NOTE_DS5 622
#define NOTE_E5  659
#define NOTE_F5  698
#define NOTE_FS5 740
#define NOTE_G5  784
#define NOTE_GS5 831
#define NOTE_A5  880
#define NOTE_AS5 932
#define NOTE_B5  988
#define NOTE_C6  1047
#define NOTE_CS6 1109
#define NOTE_D6  1175
#define NOTE_DS6 1245
#define NOTE_E6  1319
#define NOTE_F6  1397
#define NOTE_FS6 1480
#define NOTE_G6  1568
#define NOTE_GS6 1661
#define NOTE_A6  1760
#define NOTE_AS6 1865
#define NOTE_B6  1976
#define NOTE_C7  2093
#define NOTE_CS7 2217
#define NOTE_D7  2349
#define NOTE_DS7 2489
#define NOTE_E7  2637
#define NOTE_F7  2794
#define NOTE_FS7 2960
#define NOTE_G7  3136
#define NOTE_GS7 3322
#define NOTE_A7  3520
#define NOTE_AS7 3729
#define NOTE_B7  3951
#define NOTE_C8  4186
#define NOTE_CS8 4435
#define NOTE_D8  4699
#define NOTE_DS8 4978
#define NOTE_REST 0 // سکوت

void setup() {
  pinMode(buzzerPin, OUTPUT);
  Serial.begin(9600);
  
  Serial.println("========================================");
  Serial.println("   Musical Buzzer - Melody Player");
  Serial.println("========================================");
  Serial.println("Available melodies:");
  Serial.println("1. Jingle Bells");
  Serial.println("2. Happy Birthday");
  Serial.println("3. Super Mario Theme");
  Serial.println("4. Titanic - My Heart Will Go On");
  Serial.println("5. Nokia Ringtone");
  Serial.println("Type 1-5 to play a melody");
  Serial.println("----------------------------------------");
}

void loop() {
  if (Serial.available()) {
    char choice = Serial.read();
    
    switch (choice) {
      case '1':
        Serial.println("Playing: Jingle Bells");
        playJingleBells();
        break;
      case '2':
        Serial.println("Playing: Happy Birthday");
        playHappyBirthday();
        break;
      case '3':
        Serial.println("Playing: Super Mario Theme");
        playMarioTheme();
        break;
      case '4':
        Serial.println("Playing: Titanic Theme");
        playTitanic();
        break;
      case '5':
        Serial.println("Playing: Nokia Ringtone");
        playNokia();
        break;
      default:
        Serial.println("Please enter 1-5");
    }
  }
  
  delay(100);
}

// تابع اصلی پخش ملودی
void playMelody(int melody[], int noteDurations[], int length, int tempo = 200) {
  Serial.println("Playing melody...");
  
  for (int thisNote = 0; thisNote < length; thisNote++) {
    // محاسبه مدت زمان نت
    int noteDuration = tempo / noteDurations[thisNote];
    
    // پخش نت
    if (melody[thisNote] == NOTE_REST) {
      noTone(buzzerPin);
    } else {
      tone(buzzerPin, melody[thisNote], noteDuration);
    }
    
    // برای تشخیص بهتر نت‌ها، کمی فاصله بین آنها
    int pauseBetweenNotes = noteDuration * 1.30;
    delay(pauseBetweenNotes);
    
    // قطع صدای فعلی
    noTone(buzzerPin);
    
    // نمایش اطلاعات نت
    Serial.print("Note ");
    Serial.print(thisNote + 1);
    Serial.print("/");
    Serial.print(length);
    Serial.print(": ");
    Serial.print(melody[thisNote]);
    Serial.print("Hz (");
    Serial.print(noteDuration);
    Serial.println("ms)");
  }
  
  Serial.println("Melody finished!");
  noTone(buzzerPin);
}

// 1. ملودی Jingle Bells
void playJingleBells() {
  int melody[] = {
    NOTE_E4, NOTE_E4, NOTE_E4, NOTE_E4, NOTE_E4, NOTE_E4,
    NOTE_E4, NOTE_G4, NOTE_C4, NOTE_D4, NOTE_E4,
    NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4, NOTE_F4,
    NOTE_E4, NOTE_E4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_E4, NOTE_D4, NOTE_G4
  };
  
  int noteDurations[] = {
    4, 4, 2, 4, 4, 2,
    4, 4, 4, 4, 1,
    4, 4, 4, 4, 1,
    4, 4, 4, 4, 4, 4, 4, 4, 1
  };
  
  playMelody(melody, noteDurations, 25, 150);
}

// 2. ملودی Happy Birthday
void playHappyBirthday() {
  int melody[] = {
    NOTE_C4, NOTE_C4, NOTE_D4, NOTE_C4, NOTE_F4, NOTE_E4,
    NOTE_C4, NOTE_C4, NOTE_D4, NOTE_C4, NOTE_G4, NOTE_F4,
    NOTE_C4, NOTE_C4, NOTE_C5, NOTE_A4, NOTE_F4, NOTE_E4, NOTE_D4,
    NOTE_AS4, NOTE_AS4, NOTE_A4, NOTE_F4, NOTE_G4, NOTE_F4
  };
  
  int noteDurations[] = {
    4, 4, 2, 2, 2, 1,
    4, 4, 2, 2, 2, 1,
    4, 4, 2, 2, 2, 2, 2,
    4, 4, 2, 2, 2, 1
  };
  
  playMelody(melody, noteDurations, 25, 180);
}

// 3. تم Super Mario
void playMarioTheme() {
  int melody[] = {
    NOTE_E5, NOTE_E5, NOTE_REST, NOTE_E5, NOTE_REST, NOTE_C5, NOTE_E5,
    NOTE_G5, NOTE_REST, NOTE_G4, NOTE_REST,
    NOTE_C5, NOTE_REST, NOTE_G4, NOTE_REST, NOTE_E4,
    NOTE_REST, NOTE_A4, NOTE_REST, NOTE_B4, NOTE_REST, NOTE_AS4, NOTE_A4,
    NOTE_G4, NOTE_E5, NOTE_G5, NOTE_A5, NOTE_F5, NOTE_G5,
    NOTE_REST, NOTE_E5, NOTE_C5, NOTE_D5, NOTE_B4
  };
  
  int noteDurations[] = {
    8, 8, 8, 8, 8, 8, 8,
    4, 4, 4, 4,
    4, 8, 4, 8, 4,
    8, 4, 8, 4, 8, 8, 8,
    8, 8, 8, 8, 8, 8,
    8, 8, 8, 8, 2
  };
  
  playMelody(melody, noteDurations, 34, 200);
}

// 4. تم Titanic - My Heart Will Go On
void playTitanic() {
  int melody[] = {
    NOTE_C5, NOTE_G4, NOTE_AS4, NOTE_A4, NOTE_G4,
    NOTE_C5, NOTE_G4, NOTE_AS4, NOTE_A4, NOTE_G4,
    NOTE_E5, NOTE_E5, NOTE_F5, NOTE_E5, NOTE_D5,
    NOTE_C5, NOTE_C5, NOTE_D5, NOTE_C5, NOTE_AS4,
    NOTE_G4, NOTE_G4, NOTE_AS4, NOTE_A4, NOTE_G4
  };
  
  int noteDurations[] = {
    4, 8, 8, 4, 4,
    4, 8, 8, 4, 4,
    4, 8, 8, 4, 4,
    4, 8, 8, 4, 4,
    4, 8, 8, 4, 2
  };
  
  playMelody(melody, noteDurations, 25, 160);
}

// 5. زنگ نوکیا
void playNokia() {
  int melody[] = {
    NOTE_E5, NOTE_D5, NOTE_FS4, NOTE_GS4, 
    NOTE_CS5, NOTE_B4, NOTE_D4, NOTE_E4,
    NOTE_B4, NOTE_A4, NOTE_CS4, NOTE_E4,
    NOTE_A4
  };
  
  int noteDurations[] = {
    8, 8, 4, 4,
    8, 8, 4, 4,
    8, 8, 4, 4,
    2
  };
  
  playMelody(melody, noteDurations, 13, 140);
}

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

const int buzzerPin = 9;
const int buttonPin = 2;     // دکمه تست
const int ledPin = 13;       // LED نشانگر
const int potPin = A0;       // پتانسیومتر تنظیم شدت

// الگوهای هشدار
enum AlarmPattern {
  PATTERN_FIRE,      // آتش‌سوزی
  PATTERN_INTRUSION, // نفوذ
  PATTERN_EMERGENCY, // اورژانسی
  PATTERN_WARNING,   // هشدار
  PATTERN_INFO,      // اطلاع‌رسانی
  PATTERN_SUCCESS    // موفقیت
};

// متغیرهای سیستم
AlarmPattern currentPattern = PATTERN_INFO;
bool alarmActive = false;
int alarmVolume = 100; // 0-100 درصد
int alarmRepeat = 3;   // تعداد تکرار

void setup() {
  pinMode(buzzerPin, OUTPUT);
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
  
  Serial.begin(9600);
  
  Serial.println("========================================");
  Serial.println("   Intelligent Alarm System");
  Serial.println("========================================");
  Serial.println("Alarm Patterns:");
  Serial.println("F - Fire Alarm");
  Serial.println("I - Intrusion Alarm");
  Serial.println("E - Emergency Alarm");
  Serial.println("W - Warning Beep");
  Serial.println("N - Information Beep");
  Serial.println("S - Success Tone");
  Serial.println("V - Adjust Volume (via potentiometer)");
  Serial.println("R - Set repetitions (1-10)");
  Serial.println("T - Test current pattern");
  Serial.println("----------------------------------------");
}

void loop() {
  // خواندن پتانسیومتر برای تنظیم صدا
  adjustVolume();
  
  // بررسی دکمه تست
  if (digitalRead(buttonPin) == LOW) {
    delay(50); // Debouncing
    if (digitalRead(buttonPin) == LOW) {
      testAlarm();
    }
  }
  
  // بررسی دستورات سریال
  if (Serial.available()) {
    char command = Serial.read();
    processCommand(command);
  }
  
  delay(10);
}

void adjustVolume() {
  // خواندن پتانسیومتر و تبدیل به 0-100
  int potValue = analogRead(potPin);
  alarmVolume = map(potValue, 0, 1023, 0, 100);
  
  static int lastVolume = -1;
  if (abs(alarmVolume - lastVolume) > 5) { // نمایش فقط وقتی تغییر قابل توجه باشد
    Serial.print("Volume: ");
    Serial.print(alarmVolume);
    Serial.println("%");
    lastVolume = alarmVolume;
  }
}

void processCommand(char cmd) {
  switch (cmd) {
    case 'F':
    case 'f':
      currentPattern = PATTERN_FIRE;
      Serial.println("Pattern set: FIRE ALARM");
      break;
      
    case 'I':
    case 'i':
      currentPattern = PATTERN_INTRUSION;
      Serial.println("Pattern set: INTRUSION ALARM");
      break;
      
    case 'E':
    case 'e':
      currentPattern = PATTERN_EMERGENCY;
      Serial.println("Pattern set: EMERGENCY ALARM");
      break;
      
    case 'W':
    case 'w':
      currentPattern = PATTERN_WARNING;
      Serial.println("Pattern set: WARNING BEEP");
      break;
      
    case 'N':
    case 'n':
      currentPattern = PATTERN_INFO;
      Serial.println("Pattern set: INFORMATION BEEP");
      break;
      
    case 'S':
    case 's':
      currentPattern = PATTERN_SUCCESS;
      Serial.println("Pattern set: SUCCESS TONE");
      break;
      
    case 'V':
    case 'v':
      Serial.println("Adjust volume using potentiometer");
      Serial.println("Current volume: " + String(alarmVolume) + "%");
      break;
      
    case 'R':
    case 'r':
      setRepetitions();
      break;
      
    case 'T':
    case 't':
      testAlarm();
      break;
      
    case '?':
      showHelp();
      break;
  }
}

void setRepetitions() {
  Serial.println("Enter number of repetitions (1-10):");
  
  // انتظار برای ورود عدد
  while (!Serial.available()) {
    delay(10);
  }
  
  String input = Serial.readStringUntil('\n');
  input.trim();
  int reps = input.toInt();
  
  if (reps >= 1 && reps <= 10) {
    alarmRepeat = reps;
    Serial.print("Repetitions set to: ");
    Serial.println(alarmRepeat);
  } else {
    Serial.println("Invalid input. Using default (3)");
  }
}

void testAlarm() {
  if (alarmActive) {
    Serial.println("Alarm is already active!");
    return;
  }
  
  alarmActive = true;
  Serial.print("Testing alarm pattern: ");
  
  switch (currentPattern) {
    case PATTERN_FIRE:
      Serial.println("FIRE ALARM");
      fireAlarm();
      break;
      
    case PATTERN_INTRUSION:
      Serial.println("INTRUSION ALARM");
      intrusionAlarm();
      break;
      
    case PATTERN_EMERGENCY:
      Serial.println("EMERGENCY ALARM");
      emergencyAlarm();
      break;
      
    case PATTERN_WARNING:
      Serial.println("WARNING BEEP");
      warningBeep();
      break;
      
    case PATTERN_INFO:
      Serial.println("INFORMATION BEEP");
      infoBeep();
      break;
      
    case PATTERN_SUCCESS:
      Serial.println("SUCCESS TONE");
      successTone();
      break;
  }
  
  alarmActive = false;
  Serial.println("Test complete");
}

void fireAlarm() {
  // آژیر آتش‌نشانی
  digitalWrite(ledPin, HIGH);
  
  for (int r = 0; r < alarmRepeat; r++) {
    Serial.print("Cycle ");
    Serial.println(r + 1);
    
    // بوق‌های سریع و با فرکانس بالا
    for (int i = 0; i < 10; i++) {
      toneWithVolume(buzzerPin, 1500, 100);
      delay(100);
      noTone(buzzerPin);
      digitalWrite(ledPin, !digitalRead(ledPin));
    }
    
    delay(500);
    
    // بوق‌های بلند و طولانی
    for (int i = 0; i < 3; i++) {
      toneWithVolume(buzzerPin, 1000, 500);
      delay(600);
      noTone(buzzerPin);
      digitalWrite(ledPin, !digitalRead(ledPin));
      delay(200);
    }
    
    delay(1000);
  }
  
  digitalWrite(ledPin, LOW);
}

void intrusionAlarm() {
  // آژیر ضد سرقت
  digitalWrite(ledPin, HIGH);
  
  for (int r = 0; r < alarmRepeat; r++) {
    Serial.print("Cycle ");
    Serial.println(r + 1);
    
    // افکت آژیر پلیس
    for (int i = 0; i < 2; i++) {
      // افزایش فرکانس
      for (int freq = 800; freq <= 1600; freq += 50) {
        toneWithVolume(buzzerPin, freq, 30);
        delay(20);
        digitalWrite(ledPin, !digitalRead(ledPin));
      }
      
      noTone(buzzerPin);
      delay(100);
      
      // کاهش فرکانس
      for (int freq = 1600; freq >= 800; freq -= 50) {
        toneWithVolume(buzzerPin, freq, 30);
        delay(20);
        digitalWrite(ledPin, !digitalRead(ledPin));
      }
      
      noTone(buzzerPin);
      delay(300);
    }
    
    // بوق‌های تند
    for (int i = 0; i < 8; i++) {
      toneWithVolume(buzzerPin, 1200, 100);
      delay(150);
      noTone(buzzerPin);
      digitalWrite(ledPin, !digitalRead(ledPin));
      delay(50);
    }
    
    delay(1000);
  }
  
  digitalWrite(ledPin, LOW);
}

void emergencyAlarm() {
  // آژیر اورژانس
  for (int r = 0; r < alarmRepeat; r++) {
    Serial.print("Cycle ");
    Serial.println(r + 1);
    
    // الگوی سه بوقی
    for (int set = 0; set < 3; set++) {
      for (int i = 0; i < 3; i++) {
        digitalWrite(ledPin, HIGH);
        toneWithVolume(buzzerPin, 1300, 200);
        delay(300);
        noTone(buzzerPin);
        digitalWrite(ledPin, LOW);
        delay(100);
      }
      delay(500);
    }
    
    delay(1000);
  }
}

void warningBeep() {
  // هشدار ساده
  for (int r = 0; r < alarmRepeat; r++) {
    Serial.print("Beep ");
    Serial.println(r + 1);
    
    digitalWrite(ledPin, HIGH);
    toneWithVolume(buzzerPin, 1000, 500);
    delay(600);
    noTone(buzzerPin);
    digitalWrite(ledPin, LOW);
    
    delay(1000);
  }
}

void infoBeep() {
  // بوق اطلاع‌رسانی کوتاه
  for (int r = 0; r < alarmRepeat; r++) {
    Serial.print("Info ");
    Serial.println(r + 1);
    
    digitalWrite(ledPin, HIGH);
    toneWithVolume(buzzerPin, 800, 100);
    delay(150);
    noTone(buzzerPin);
    digitalWrite(ledPin, LOW);
    
    delay(300);
  }
}

void successTone() {
  // صدای موفقیت
  for (int r = 0; r < alarmRepeat; r++) {
    Serial.print("Success ");
    Serial.println(r + 1);
    
    // ملودی کوتاه موفقیت
    int successMelody[] = {NOTE_C5, NOTE_E5, NOTE_G5, NOTE_C6};
    int durations[] = {8, 8, 8, 4};
    
    for (int i = 0; i < 4; i++) {
      digitalWrite(ledPin, HIGH);
      toneWithVolume(buzzerPin, successMelody[i], 1000 / durations[i]);
      delay(1200 / durations[i]);
      noTone(buzzerPin);
      digitalWrite(ledPin, LOW);
      delay(50);
    }
    
    delay(800);
  }
}

void toneWithVolume(int pin, int frequency, int duration) {
  // شبیه‌سازی کنترل حجم با PWM
  // در بازر غیرفعال واقعی، کنترل حجم با ولتاژ یا PWM روی سیگنال امکان‌پذیر است
  // این یک شبیه‌سازی ساده است
  
  if (alarmVolume == 0) {
    noTone(pin);
    return;
  }
  
  // برای شبیه‌سازی: اگر حجم کم است، مدت زمان کمتری صدا بده
  int adjustedDuration = duration * alarmVolume / 100;
  
  // همچنین فرکانس را کمی تغییر دهیم برای اثر حجم
  int adjustedFreq = frequency;
  if (alarmVolume < 30) {
    adjustedFreq = frequency * 0.9; // کمی بم‌تر
  }
  
  tone(pin, adjustedFreq, adjustedDuration);
}

void showHelp() {
  Serial.println("\n=== INTELLIGENT ALARM SYSTEM ===");
  Serial.println("This system provides different alarm patterns");
  Serial.println("for various emergency and notification scenarios.");
  Serial.println();
  Serial.println("Available Commands:");
  Serial.println("F - Fire Alarm (rapid beeps + long tones)");
  Serial.println("I - Intrusion Alarm (siren + rapid beeps)");
  Serial.println("E - Emergency Alarm (triple beep pattern)");
  Serial.println("W - Warning Beep (single long beep)");
  Serial.println("N - Information Beep (short beep)");
  Serial.println("S - Success Tone (rising melody)");
  Serial.println("V - Show volume info");
  Serial.println("R - Set number of repetitions");
  Serial.println("T - Test current alarm pattern");
  Serial.println("? - Show this help");
  Serial.println();
  Serial.println("Hardware:");
  Serial.println("- Potentiometer adjusts volume");
  Serial.println("- Button tests current pattern");
  Serial.println("- LED shows alarm activity");
  Serial.println("==============================\n");
}

/*
 * مترونوم دیجیتال با بازر غیرفعال
 * با قابلیت تنظیم تمپو و میزان‌سنجی
 */

const int buzzerPin = 9;
const int buttonPlus = 2;    // افزایش تمپو
const int buttonMinus = 3;   // کاهش تمپو
const int buttonStart = 4;   // شروع/توقف
const int ledPin = 13;

// تنظیمات مترونوم
int tempo = 120; // ضرب در دقیقه (BPM)
int beatsPerMeasure = 4; // میزان‌سنجی: 4/4
bool metronomeRunning = false;
unsigned long lastBeatTime = 0;
int currentBeat = 0;

// فرکانس‌های مختلف برای ضرب قوی و ضعیف
const int STRONG_BEAT_FREQ = 1500; // ضرب قوی
const int WEAK_BEAT_FREQ = 800;    // ضرب ضعیف

void setup() {
  pinMode(buzzerPin, OUTPUT);
  pinMode(buttonPlus, INPUT_PULLUP);
  pinMode(buttonMinus, INPUT_PULLUP);
  pinMode(buttonStart, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
  
  Serial.begin(9600);
  
  Serial.println("========================================");
  Serial.println("   Digital Metronome with Buzzer");
  Serial.println("========================================");
  Serial.println("Controls:");
  Serial.println("Button + : Increase tempo");
  Serial.println("Button - : Decrease tempo");
  Serial.println("Button S : Start/Stop");
  Serial.println();
  Serial.println("Current settings:");
  displayStatus();
  Serial.println("----------------------------------------");
}

void loop() {
  // خواندن دکمه‌ها
  readButtons();
  
  // اجرای مترونوم اگر فعال باشد
  if (metronomeRunning) {
    runMetronome();
  }
  
  // نمایش وضعیت دوره‌ای
  static unsigned long lastDisplay = 0;
  if (millis() - lastDisplay > 5000) {
    displayStatus();
    lastDisplay = millis();
  }
  
  delay(10);
}

void readButtons() {
  static unsigned long lastPlusPress = 0;
  static unsigned long lastMinusPress = 0;
  static unsigned long lastStartPress = 0;
  
  // دکمه افزایش تمپو
  if (digitalRead(buttonPlus) == LOW && millis() - lastPlusPress > 200) {
    if (tempo < 300) {
      tempo += 5;
      Serial.print("Tempo increased to: ");
      Serial.println(tempo);
      lastPlusPress = millis();
    }
  }
  
  // دکمه کاهش تمپو
  if (digitalRead(buttonMinus) == LOW && millis() - lastMinusPress > 200) {
    if (tempo > 40) {
      tempo -= 5;
      Serial.print("Tempo decreased to: ");
      Serial.println(tempo);
      lastMinusPress = millis();
    }
  }
  
  // دکمه شروع/توقف
  if (digitalRead(buttonStart) == LOW && millis() - lastStartPress > 300) {
    metronomeRunning = !metronomeRunning;
    currentBeat = 0;
    
    if (metronomeRunning) {
      Serial.println("Metronome STARTED");
      lastBeatTime = millis();
    } else {
      Serial.println("Metronome STOPPED");
      digitalWrite(ledPin, LOW);
      noTone(buzzerPin);
    }
    
    lastStartPress = millis();
  }
}

void runMetronome() {
  // محاسبه فاصله بین ضرب‌ها (میلی‌ثانیه)
  unsigned long beatInterval = 60000 / tempo; // 60,000ms / BPM
  
  // بررسی زمان ضرب بعدی
  if (millis() - lastBeatTime >= beatInterval) {
    playBeat();
    lastBeatTime = millis();
    currentBeat = (currentBeat % beatsPerMeasure) + 1;
  }
}

void playBeat() {
  // انتخاب فرکانس بر اساس ضرب قوی یا ضعیف
  int frequency;
  
  if (currentBeat == 1) {
    // ضرب اول (قوی)
    frequency = STRONG_BEAT_FREQ;
    digitalWrite(ledPin, HIGH);
    Serial.print("[");
  } else {
    // ضرب‌های بعدی (ضعیف)
    frequency = WEAK_BEAT_FREQ;
    digitalWrite(ledPin, LOW);
    Serial.print(" ");
  }
  
  // پخش ضرب
  tone(buzzerPin, frequency, 50);
  
  // نمایش ضرب
  Serial.print("X");
  if (currentBeat == beatsPerMeasure) {
    Serial.print("] ");
  }
  
  // چشمک زدن LED برای ضرب قوی
  if (currentBeat == 1) {
    delay(50);
    digitalWrite(ledPin, LOW);
  }
}

void displayStatus() {
  Serial.println("\n=== METRONOME STATUS ===");
  Serial.print("Tempo: ");
  Serial.print(tempo);
  Serial.println(" BPM");
  
  Serial.print("Time signature: ");
  Serial.print(beatsPerMeasure);
  Serial.println("/4");
  
  Serial.print("Beat interval: ");
  Serial.print(60000 / tempo);
  Serial.println(" ms");
  
  Serial.print("State: ");
  Serial.println(metronomeRunning ? "RUNNING" : "STOPPED");
  
  if (metronomeRunning) {
    Serial.print("Current beat: ");
    Serial.print(currentBeat);
    Serial.print(" of ");
    Serial.println(beatsPerMeasure);
  }
  
  Serial.println("=======================\n");
}

// محدود کردن استفاده پیوسته
void safeTone(int pin, int freq, int duration) {
  tone(pin, freq, duration);
  delay(duration + 50); // اضافه کردن تأخیر ایمنی
  noTone(pin);
  
  // استراحت بین استفاده‌های طولانی
  if (duration > 1000) {
    delay(100);
  }
}

// پخش ملودی مختلف با هر بار فشار دکمه

// هشدار پایان زمان پخت با ملودی متفاوت

// دنبال کردن ملودی و تکرار آن

// هشدار پر یا خالی شدن مخزن آب

// تولید نت‌های تصادفی برای تمرین