ماژول بازر فعال

// اتصال ساده بازر فعال به آردوینو
#define BUZZER_PIN 8

void setup() {
  pinMode(BUZZER_PIN, OUTPUT);
  digitalWrite(BUZZER_PIN, LOW); // ابتدا خاموش
  
  Serial.begin(9600);
  Serial.println("بازر فعال راه‌اندازی شد");
}

void loop() {
  // بوق ساده
  Serial.println("بوق 1 ثانیه");
  digitalWrite(BUZZER_PIN, HIGH); // روشن
  delay(1000);
  digitalWrite(BUZZER_PIN, LOW);  // خاموش
  delay(1000);
  
  // بوق کوتاه (3 بار)
  Serial.println("3 بوق کوتاه");
  for(int i=0; i<3; i++) {
    digitalWrite(BUZZER_PIN, HIGH);
    delay(200);
    digitalWrite(BUZZER_PIN, LOW);
    delay(200);
  }
  delay(1000);
}

// برای ولتاژهای بالاتر از 5V یا جریان زیاد
#define BUZZER_CONTROL 9
#define BUZZER_VCC 12  // تغذیه 12V جداگانه

void setup() {
  pinMode(BUZZER_CONTROL, OUTPUT);
  
  // استفاده از ترانزیستور NPN
  // بیس ← آردوینو
  // امیتر ← GND
  // کلکتور ← بازر ← 12V
}

void controlBuzzer(bool state) {
  digitalWrite(BUZZER_CONTROL, state ? HIGH : LOW);
}

class ActiveBuzzer {
  private:
    int pin;
    bool isActive;
    unsigned long beepStartTime;
    unsigned long beepDuration;
    
  public:
    ActiveBuzzer(int buzzerPin) {
      pin = buzzerPin;
      isActive = false;
      beepStartTime = 0;
      beepDuration = 0;
      
      pinMode(pin, OUTPUT);
      off(); // ابتدا خاموش
    }
    
    // روشن کردن
    void on() {
      digitalWrite(pin, HIGH);
      isActive = true;
    }
    
    // خاموش کردن
    void off() {
      digitalWrite(pin, LOW);
      isActive = false;
    }
    
    // بوق با مدت مشخص
    void beep(unsigned long durationMs) {
      on();
      beepStartTime = millis();
      beepDuration = durationMs;
    }
    
    // بوق متناوب
    void beepPattern(int beeps, int onTime, int offTime) {
      for(int i=0; i<beeps; i++) {
        on();
        delay(onTime);
        off();
        if(i < beeps-1) delay(offTime);
      }
    }
    
    // آلارم ویژه
    void alarm(int type) {
      switch(type) {
        case 1: // آلارم کوتاه
          beepPattern(3, 100, 100);
          break;
        case 2: // آلارم طولانی
          beepPattern(2, 500, 200);
          break;
        case 3: // آلارم SOS
          // سه کوتاه، سه بلند، سه کوتاه
          beepPattern(3, 200, 200);
          delay(400);
          beepPattern(3, 500, 200);
          delay(400);
          beepPattern(3, 200, 200);
          break;
        case 4: // آلارم هشدار
          for(int i=0; i<5; i++) {
            on();
            delay(50);
            off();
            delay(50);
          }
          break;
      }
    }
    
    // به‌روزرسانی وضعیت (برای بوق‌های زمان‌دار)
    void update() {
      if(isActive && beepDuration > 0) {
        if(millis() - beepStartTime >= beepDuration) {
          off();
          beepDuration = 0;
        }
      }
    }
    
    // تست عملکرد
    void test() {
      Serial.println("تست بازر فعال...");
      
      Serial.println("1. بوق کوتاه");
      beep(300);
      delay(1000);
      
      Serial.println("2. بوق متناوب");
      beepPattern(5, 100, 100);
      delay(1000);
      
      Serial.println("3. آلارم SOS");
      alarm(3);
      delay(1000);
      
      Serial.println("تست کامل شد");
    }
    
    bool getState() {
      return isActive;
    }
};

// استفاده از کلاس
ActiveBuzzer buzzer(8);

void setup() {
  Serial.begin(9600);
  buzzer.test();
}

void loop() {
  static unsigned long lastAlarm = 0;
  
  // آلارم هر 10 ثانیه
  if(millis() - lastAlarm > 10000) {
    lastAlarm = millis();
    buzzer.alarm(1);
    Serial.println("آلارم فعال شد");
  }
  
  buzzer.update(); // به‌روزرسانی وضعیت
}

enum AlarmType {
  ALARM_NONE,
  ALARM_INFO,
  ALARM_WARNING,
  ALARM_ERROR,
  ALARM_CRITICAL
};

class AlarmSystem {
  private:
    ActiveBuzzer* buzzer;
    AlarmType currentAlarm;
    unsigned long alarmStartTime;
    bool isMuted;
    
  public:
    AlarmSystem(int buzzerPin) {
      buzzer = new ActiveBuzzer(buzzerPin);
      currentAlarm = ALARM_NONE;
      alarmStartTime = 0;
      isMuted = false;
    }
    
    void triggerAlarm(AlarmType type) {
      if(isMuted) return;
      
      currentAlarm = type;
      alarmStartTime = millis();
      
      switch(type) {
        case ALARM_INFO:
          // بوق کوتاه تک‌باره
          buzzer->beep(200);
          Serial.println("هشدار: اطلاعات");
          break;
          
        case ALARM_WARNING:
          // دو بوق کوتاه
          buzzer->beepPattern(2, 200, 100);
          Serial.println("هشدار: اخطار");
          break;
          
        case ALARM_ERROR:
          // سه بوق سریع
          buzzer->beepPattern(3, 100, 50);
          Serial.println("هشدار: خطا");
          break;
          
        case ALARM_CRITICAL:
          // بوق ممتد با چشمک‌زن
          buzzer->on();
          Serial.println("هشدار: بحرانی");
          break;
          
        default:
          buzzer->off();
      }
    }
    
    void update() {
      buzzer->update();
      
      // قطع خودکار آلارم‌های غیرممتد
      if(currentAlarm != ALARM_CRITICAL && currentAlarm != ALARM_NONE) {
        if(millis() - alarmStartTime > 3000) { // بعد از 3 ثانیه
          stopAlarm();
        }
      }
    }
    
    void stopAlarm() {
      buzzer->off();
      currentAlarm = ALARM_NONE;
    }
    
    void mute() {
      isMuted = true;
      stopAlarm();
      Serial.println("آلارم سایلنت شد");
    }
    
    void unmute() {
      isMuted = false;
      Serial.println("آلارم فعال شد");
    }
    
    AlarmType getCurrentAlarm() {
      return currentAlarm;
    }
};

// استفاده
AlarmSystem alarm(8);

void setup() {
  Serial.begin(9600);
  Serial.println("سیستم آلارم راه‌اندازی شد");
}

void loop() {
  static int alarmCounter = 0;
  
  // شبیه‌سازی آلارم‌های مختلف
  if(millis() % 15000 < 100) { // هر 15 ثانیه
    alarmCounter = (alarmCounter + 1) % 4;
    
    switch(alarmCounter) {
      case 0: alarm.triggerAlarm(ALARM_INFO); break;
      case 1: alarm.triggerAlarm(ALARM_WARNING); break;
      case 2: alarm.triggerAlarm(ALARM_ERROR); break;
      case 3: alarm.triggerAlarm(ALARM_CRITICAL); break;
    }
  }
  
  // خاموش کردن آلارم بحرانی بعد از 5 ثانیه
  if(alarm.getCurrentAlarm() == ALARM_CRITICAL) {
    static unsigned long criticalStart = 0;
    if(criticalStart == 0) criticalStart = millis();
    
    if(millis() - criticalStart > 5000) {
      alarm.stopAlarm();
      criticalStart = 0;
    }
  }
  
  alarm.update();
  delay(10);
}

فرمول: R = (Vcc - Vbuzzer) / Ibuzzer

مثال برای منبع 12V و بازر 5V/30mA:
R = (12V - 5V) / 0.03A = 233Ω

استفاده از مقاومت 220Ω 1/4W

class KitchenTimer {
  private:
    ActiveBuzzer buzzer;
    unsigned long endTime;
    bool isRunning;
    
  public:
    KitchenTimer(int pin) : buzzer(pin) {
      isRunning = false;
      endTime = 0;
    }
    
    void setTimer(unsigned long seconds) {
      endTime = millis() + (seconds * 1000);
      isRunning = true;
      Serial.print("تایمر برای ");
      Serial.print(seconds);
      Serial.println(" ثانیه تنظیم شد");
    }
    
    void update() {
      if(isRunning && millis() >= endTime) {
        isRunning = false;
        triggerAlarm();
      }
      buzzer.update();
    }
    
    void triggerAlarm() {
      Serial.println("زمان به پایان رسید!");
      // آلارم 5 ثانیه‌ای
      buzzer.beepPattern(10, 250, 250);
    }
    
    void cancel() {
      isRunning = false;
      buzzer.off();
      Serial.println("تایمر لغو شد");
    }
};

KitchenTimer timer(8);

void setup() {
  Serial.begin(9600);
  Serial.println("تایمر آشپزخانه راه‌اندازی شد");
  timer.setTimer(10); // تست 10 ثانیه
}

void loop() {
  timer.update();
  delay(10);
}

class TemperatureAlarm {
  private:
    ActiveBuzzer buzzer;
    float thresholdHigh;
    float thresholdLow;
    bool alarmActive;
    
  public:
    TemperatureAlarm(int pin, float high, float low) : buzzer(pin) {
      thresholdHigh = high;
      thresholdLow = low;
      alarmActive = false;
    }
    
    void checkTemperature(float currentTemp) {
      if(currentTemp > thresholdHigh) {
        if(!alarmActive) {
          triggerHighTempAlarm();
          alarmActive = true;
        }
      } else if(currentTemp < thresholdLow) {
        if(!alarmActive) {
          triggerLowTempAlarm();
          alarmActive = true;
        }
      } else {
        if(alarmActive) {
          buzzer.off();
          alarmActive = false;
          Serial.println("دما نرمال - آلارم خاموش");
        }
      }
      
      buzzer.update();
    }
    
    void triggerHighTempAlarm() {
      Serial.println("هشدار: دمای بالا!");
      // بوق سریع برای دمای بالا
      buzzer.beepPattern(5, 100, 100);
    }
    
    void triggerLowTempAlarm() {
      Serial.println("هشدار: دمای پایین!");
      // بوق آهسته برای دمای پایین
      buzzer.beepPattern(3, 500, 500);
    }
};

TemperatureAlarm tempAlarm(8, 35.0, 10.0);

void loop() {
  float temperature = readTemperature(); // تابع خواندن دما
  tempAlarm.checkTemperature(temperature);
  delay(1000);
}

class BatteryMonitor {
  private:
    ActiveBuzzer buzzer;
    float voltage;
    float lowVoltageThreshold;
    float criticalVoltageThreshold;
    
  public:
    BatteryMonitor(int pin, float low, float critical) : buzzer(pin) {
      lowVoltageThreshold = low;
      criticalVoltageThreshold = critical;
      voltage = 0;
    }
    
    void updateVoltage(float newVoltage) {
      voltage = newVoltage;
      
      if(voltage < criticalVoltageThreshold) {
        triggerCriticalAlarm();
      } else if(voltage < lowVoltageThreshold) {
        triggerLowBatteryAlarm();
      } else {
        buzzer.off();
      }
      
      buzzer.update();
    }
    
    void triggerLowBatteryAlarm() {
      // یک بوق هر 30 ثانیه
      static unsigned long lastBeep = 0;
      if(millis() - lastBeep > 30000) {
        lastBeep = millis();
        buzzer.beep(500);
        Serial.print("هشدار: باتری ضعیف - ");
        Serial.print(voltage);
        Serial.println("V");
      }
    }
    
    void triggerCriticalAlarm() {
      // بوق ممتد
      buzzer.on();
      Serial.print("هشدار بحرانی: باتری خیلی ضعیف - ");
      Serial.print(voltage);
      Serial.println("V");
    }
};

BatteryMonitor battery(8, 3.3, 3.0); // برای باتری لیتیوم 3.7V

void loop() {
  float batteryVoltage = readBatteryVoltage();
  battery.updateVoltage(batteryVoltage);
  delay(1000);
}

// ایجاد الگوهای صوتی جالب
void playMelody() {
  // کدهای ساده ملودی
  int melody[] = {1, 1, 0, 1, 0, 0, 1, 0};
  int durations[] = {200, 200, 100, 200, 100, 100, 200, 500};
  
  for(int i=0; i<8; i++) {
    if(melody[i] == 1) {
      digitalWrite(BUZZER_PIN, HIGH);
    }
    delay(durations[i]);
    digitalWrite(BUZZER_PIN, LOW);
    delay(50);
  }
}